libcore: Move core tests into libcore

src/libcore/bool.rs

@@ -85,6 +85,26 @@ fn all_values(blk: block(v: t)) {
 )]
 pure fn to_bit(v: t) -> u8 { if v { 1u8 } else { 0u8 } }
 
+#[test]
+fn test_bool_from_str() {
+    all_values { |v|
+        assert v == from_str(bool::to_str(v))
+    }
+}
+
+#[test]
+fn test_bool_to_str() {
+    assert to_str(false) == "false";
+    assert to_str(true) == "true";
+}
+
+#[test]
+fn test_bool_to_bit() {
+    all_values { |v|
+        assert to_bit(v) == if is_true(v) { 1u8 } else { 0u8 };
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/libcore/box.rs

@@ -11,3 +11,13 @@ pure fn ptr_eq<T>(a: @T, b: @T) -> bool {
         ret a_ptr == b_ptr;
     }
 }
+
+#[test]
+fn test() {
+    let x = @3;
+    let y = @3;
+    assert (ptr_eq::<int>(x, x));
+    assert (ptr_eq::<int>(y, y));
+    assert (!ptr_eq::<int>(x, y));
+    assert (!ptr_eq::<int>(y, x));
+}

src/libcore/char.rs

@@ -147,3 +147,77 @@ pure fn cmp(a: char, b: char) -> int {
     else if b < a { 1 }
     else { 0 }
 }
+
+#[test]
+fn test_is_lowercase() {
+    assert is_lowercase('a');
+    assert is_lowercase('ö');
+    assert is_lowercase('ß');
+    assert !is_lowercase('Ü');
+    assert !is_lowercase('P');
+}
+
+#[test]
+fn test_is_uppercase() {
+    assert !is_uppercase('h');
+    assert !is_uppercase('ä');
+    assert !is_uppercase('ß');
+    assert is_uppercase('Ö');
+    assert is_uppercase('T');
+}
+
+#[test]
+fn test_is_whitespace() {
+    assert is_whitespace(' ');
+    assert is_whitespace('\u2007');
+    assert is_whitespace('\t');
+    assert is_whitespace('\n');
+
+    assert !is_whitespace('a');
+    assert !is_whitespace('_');
+    assert !is_whitespace('\u0000');
+}
+
+#[test]
+fn test_to_digit() {
+    assert (to_digit('0') == 0u8);
+    assert (to_digit('1') == 1u8);
+    assert (to_digit('2') == 2u8);
+    assert (to_digit('9') == 9u8);
+    assert (to_digit('a') == 10u8);
+    assert (to_digit('A') == 10u8);
+    assert (to_digit('b') == 11u8);
+    assert (to_digit('B') == 11u8);
+    assert (to_digit('z') == 35u8);
+    assert (to_digit('Z') == 35u8);
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(target_os = "win32"))]
+fn test_to_digit_fail_1() {
+    to_digit(' ');
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(target_os = "win32"))]
+fn test_to_digit_fail_2() {
+    to_digit('$');
+}
+
+#[test]
+fn test_to_lower() {
+    assert (to_lower('H') == 'h');
+    assert (to_lower('e') == 'e');
+    //assert (to_lower('Ö') == 'ö');
+    assert (to_lower('ß') == 'ß');
+}
+
+#[test]
+fn test_to_upper() {
+    assert (to_upper('l') == 'L');
+    assert (to_upper('Q') == 'Q');
+    //assert (to_upper('ü') == 'Ü');
+    assert (to_upper('ß') == 'ß');
+}

src/libcore/comm.rs

@@ -156,3 +156,46 @@ fn recv_<T: send>(p: *rustrt::rust_port) -> T {
 fn chan<T: send>(p: port<T>) -> chan<T> {
     chan_t(task::get_task(), rustrt::get_port_id(***p))
 }
+
+#[test]
+fn create_port_and_chan() { let p = port::<int>(); chan(p); }
+
+#[test]
+fn send_int() {
+    let p = port::<int>();
+    let c = chan(p);
+    send(c, 22);
+}
+
+#[test]
+fn send_recv_fn() {
+    let p = port::<int>();
+    let c = chan::<int>(p);
+    send(c, 42);
+    assert (recv(p) == 42);
+}
+
+#[test]
+fn send_recv_fn_infer() {
+    let p = port();
+    let c = chan(p);
+    send(c, 42);
+    assert (recv(p) == 42);
+}
+
+#[test]
+fn chan_chan_infer() {
+    let p = port(), p2 = port::<int>();
+    let c = chan(p);
+    send(c, chan(p2));
+    recv(p);
+}
+
+#[test]
+fn chan_chan() {
+    let p = port::<chan<int>>(), p2 = port::<int>();
+    let c = chan(p);
+    send(c, chan(p2));
+    recv(p);
+}
+

src/libcore/either.rs

@@ -130,3 +130,96 @@ pure fn is_right<T, U>(eith: t<T, U>) -> bool {
 // buffer-file-coding-system: utf-8-unix
 // End:
 //
+
+#[test]
+fn test_either_left() {
+    let val = left(10);
+    fn f_left(&&x: int) -> bool { x == 10 }
+    fn f_right(&&_x: uint) -> bool { false }
+    assert (either(f_left, f_right, val));
+}
+
+#[test]
+fn test_either_right() {
+    let val = right(10u);
+    fn f_left(&&_x: int) -> bool { false }
+    fn f_right(&&x: uint) -> bool { x == 10u }
+    assert (either(f_left, f_right, val));
+}
+
+#[test]
+fn test_lefts() {
+    let input = [left(10), right(11), left(12), right(13), left(14)];
+    let result = lefts(input);
+    assert (result == [10, 12, 14]);
+}
+
+#[test]
+fn test_lefts_none() {
+    let input: [t<int, int>] = [right(10), right(10)];
+    let result = lefts(input);
+    assert (vec::len(result) == 0u);
+}
+
+#[test]
+fn test_lefts_empty() {
+    let input: [t<int, int>] = [];
+    let result = lefts(input);
+    assert (vec::len(result) == 0u);
+}
+
+#[test]
+fn test_rights() {
+    let input = [left(10), right(11), left(12), right(13), left(14)];
+    let result = rights(input);
+    assert (result == [11, 13]);
+}
+
+#[test]
+fn test_rights_none() {
+    let input: [t<int, int>] = [left(10), left(10)];
+    let result = rights(input);
+    assert (vec::len(result) == 0u);
+}
+
+#[test]
+fn test_rights_empty() {
+    let input: [t<int, int>] = [];
+    let result = rights(input);
+    assert (vec::len(result) == 0u);
+}
+
+#[test]
+fn test_partition() {
+    let input = [left(10), right(11), left(12), right(13), left(14)];
+    let result = partition(input);
+    assert (result.lefts[0] == 10);
+    assert (result.lefts[1] == 12);
+    assert (result.lefts[2] == 14);
+    assert (result.rights[0] == 11);
+    assert (result.rights[1] == 13);
+}
+
+#[test]
+fn test_partition_no_lefts() {
+    let input: [t<int, int>] = [right(10), right(11)];
+    let result = partition(input);
+    assert (vec::len(result.lefts) == 0u);
+    assert (vec::len(result.rights) == 2u);
+}
+
+#[test]
+fn test_partition_no_rights() {
+    let input: [t<int, int>] = [left(10), left(11)];
+    let result = partition(input);
+    assert (vec::len(result.lefts) == 2u);
+    assert (vec::len(result.rights) == 0u);
+}
+
+#[test]
+fn test_partition_empty() {
+    let input: [t<int, int>] = [];
+    let result = partition(input);
+    assert (vec::len(result.lefts) == 0u);
+    assert (vec::len(result.rights) == 0u);
+}

src/libcore/float.rs

@@ -281,6 +281,87 @@ fn pow_uint_to_uint_as_float(x: uint, pow: uint) -> float {
 }
 
 
+#[test]
+fn test_from_str() {
+   assert ( from_str("3") == 3. );
+   assert ( from_str("  3  ") == 3. );
+   assert ( from_str("3.14") == 3.14 );
+   assert ( from_str("+3.14") == 3.14 );
+   assert ( from_str("-3.14") == -3.14 );
+   assert ( from_str("2.5E10") == 25000000000. );
+   assert ( from_str("2.5e10") == 25000000000. );
+   assert ( from_str("25000000000.E-10") == 2.5 );
+   assert ( from_str("") == 0. );
+   assert ( from_str(".") == 0. );
+   assert ( from_str(".e1") == 0. );
+   assert ( from_str(".e-1") == 0. );
+   assert ( from_str("5.") == 5. );
+   assert ( from_str(".5") == 0.5 );
+   assert ( from_str("0.5") == 0.5 );
+   assert ( from_str("0.5 ") == 0.5 );
+   assert ( from_str(" 0.5 ") == 0.5 );
+   assert ( from_str(" -.5 ") == -0.5 );
+   assert ( from_str(" -.5 ") == -0.5 );
+   assert ( from_str(" -5 ") == -5. );
+
+   assert ( is_NaN(from_str("x")) );
+   assert ( from_str(" ") == 0. );
+   assert ( from_str("   ") == 0. );
+   assert ( from_str(" 0.5") == 0.5 );
+   assert ( from_str(" 0.5 ") == 0.5 );
+   assert ( from_str(" .1 ") == 0.1 );
+   assert ( is_NaN(from_str("e")) );
+   assert ( is_NaN(from_str("E")) );
+   assert ( is_NaN(from_str("E1")) );
+   assert ( is_NaN(from_str("1e1e1")) );
+   assert ( is_NaN(from_str("1e1.1")) );
+   assert ( is_NaN(from_str("1e1-1")) );
+}
+
+#[test]
+fn test_positive() {
+  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]
+fn test_negative() {
+  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]
+fn test_nonpositive() {
+  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]
+fn test_nonnegative() {
+  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));
+}
+
 //
 // Local Variables:
 // mode: rust

src/libcore/int.rs

@@ -180,6 +180,101 @@ fn pow(base: int, exponent: uint) -> int {
     }
     ret acc;
 }
+
+#[test]
+fn test_from_str() {
+    assert(from_str("0") == 0);
+    assert(from_str("3") == 3);
+    assert(from_str("10") == 10);
+    assert(from_str("123456789") == 123456789);
+    assert(from_str("00100") == 100);
+
+    assert(from_str("-1") == -1);
+    assert(from_str("-3") == -3);
+    assert(from_str("-10") == -10);
+    assert(from_str("-123456789") == -123456789);
+    assert(from_str("-00100") == -100);
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(target_os = "win32"))]
+fn test_from_str_fail_1() {
+    from_str(" ");
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(target_os = "win32"))]
+fn test_from_str_fail_2() {
+    from_str("x");
+}
+
+#[test]
+fn test_parse_buf() {
+    import str::bytes;
+    assert (parse_buf(bytes("123"), 10u) == 123);
+    assert (parse_buf(bytes("1001"), 2u) == 9);
+    assert (parse_buf(bytes("123"), 8u) == 83);
+    assert (parse_buf(bytes("123"), 16u) == 291);
+    assert (parse_buf(bytes("ffff"), 16u) == 65535);
+    assert (parse_buf(bytes("FFFF"), 16u) == 65535);
+    assert (parse_buf(bytes("z"), 36u) == 35);
+    assert (parse_buf(bytes("Z"), 36u) == 35);
+
+    assert (parse_buf(bytes("-123"), 10u) == -123);
+    assert (parse_buf(bytes("-1001"), 2u) == -9);
+    assert (parse_buf(bytes("-123"), 8u) == -83);
+    assert (parse_buf(bytes("-123"), 16u) == -291);
+    assert (parse_buf(bytes("-ffff"), 16u) == -65535);
+    assert (parse_buf(bytes("-FFFF"), 16u) == -65535);
+    assert (parse_buf(bytes("-z"), 36u) == -35);
+    assert (parse_buf(bytes("-Z"), 36u) == -35);
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(target_os = "win32"))]
+fn test_parse_buf_fail_1() {
+    parse_buf(str::bytes("Z"), 35u);
+}
+
+#[test]
+#[should_fail]
+#[ignore(cfg(target_os = "win32"))]
+fn test_parse_buf_fail_2() {
+    parse_buf(str::bytes("-9"), 2u);
+}
+
+#[test]
+fn test_to_str() {
+    import str::eq;
+    assert (eq(to_str(0, 10u), "0"));
+    assert (eq(to_str(1, 10u), "1"));
+    assert (eq(to_str(-1, 10u), "-1"));
+    assert (eq(to_str(255, 16u), "ff"));
+    assert (eq(to_str(100, 10u), "100"));
+}
+
+#[test]
+fn test_pow() {
+    assert (pow(0, 0u) == 1);
+    assert (pow(0, 1u) == 0);
+    assert (pow(0, 2u) == 0);
+    assert (pow(-1, 0u) == 1);
+    assert (pow(1, 0u) == 1);
+    assert (pow(-3, 2u) == 9);
+    assert (pow(-3, 3u) == -27);
+    assert (pow(4, 9u) == 262144);
+}
+
+#[test]
+fn test_overflows() {
+   assert (max_value > 0);
+   assert (min_value <= 0);
+   assert (min_value + max_value + 1 == 0);
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/libcore/math.rs

@@ -16,3 +16,298 @@ Returns the maximum of two values
 */
 pure fn max<T: copy>(x: T, y: T) -> T { x < y ? y : x }
 
+#[test]
+fn test_max_min() {
+    assert max(0, 1) == 1;
+    assert min(0, 1) == 0;
+    assert max(0, -1) == 0;
+    assert min(0, -1) == -1;
+    assert max(0.0, 1.0) == 1.0;
+    assert min(0.0, 1.0) == 0.0;
+}
+
+// FIXME use macros to execute the tests below for all float types
+
+/*
+#[test]
+fn test_trig() {
+    assert sin(0.0) == 0.0;
+    assert sin(-0.0) == 0.0;
+
+    assert float::isNaN(sin(float::infinity));
+    assert float::isNaN(sin(float::neg_infinity));
+
+    assert cos(0.0) == 1.0;
+    assert cos(-0.0) == 1.0;
+    assert float::isNaN(cos(float::infinity));
+    assert float::isNaN(cos(float::neg_infinity));
+
+    assert tan(0.0) == 0.0;
+    assert tan(-0.0) == 0.0;;
+    assert float::isNaN(tan(float::infinity));
+    assert float::isNaN(tan(float::neg_infinity));
+}
+
+#[test]
+fn test_inv_trig() {
+    assert asin(0.0) == 0.0;
+    assert asin(-0.0) == -0.0;
+    assert float::isNaN(asin(1.1));
+    assert float::isNaN(asin(-1.1));
+
+    assert acos(1.0) == 0.0;
+    assert float::isNaN(acos(1.1));
+    assert float::isNaN(acos(-1.1));
+
+    assert atan(0.0) == 0.0;
+    assert atan(-0.0) == 0.0;
+    assert atan(float::infinity) == consts::frac_pi_2;
+    assert atan(float::neg_infinity) == - consts::frac_pi_2;
+
+    assert atan2(0.0, -0.0) == consts::pi;
+    assert atan2(-0.0, -0.0) == -consts::pi;
+
+    assert atan2(0.0, 0.0) == 0.0;
+    assert atan2(-0.0, 0.0) == -0.0;
+
+    assert atan2(0.0, -1.0) == consts::pi;
+    assert atan2(-0.0, -1.0) == -consts::pi;
+
+    assert atan2(0.0, 1.0) == 0.0;
+    assert atan2(-0.0, 1.0) == -0.0;
+
+    assert atan2(1.0, 0.0) == consts::frac_pi_2;
+    assert atan2(1.0, -0.0) == consts::frac_pi_2;
+}
+
+// FIXME (1222): The commented-out tests give different results on windows
+#[test]
+fn test_pow() {
+    assert pow(2.0, 4.0) == 16.0;
+
+    assert pow(0.0, -3.0) == float::infinity;
+    assert pow(-0.0, -3.0) == float::neg_infinity;
+
+    assert pow(0.0, -4.0) == float::infinity;
+    assert pow(-0.0, -4.0) == float::infinity;
+
+    assert pow(0.0, 3.0) == 0.0;
+    assert pow(-0.0, 3.0) == -0.0;
+    assert pow(0.0, 4.0) == 0.0;
+    assert pow(-0.0, 4.0) == 0.0;
+
+    assert pow(-1.0, float::infinity) == 1.0;
+    //assert pow(-1.0, float::neg_infinity) == 1.0;
+
+    assert pow(1.0, 4.0) == 1.0;
+    assert pow(1.0, 0.0) == 1.0;
+    assert pow(1.0, -0.0) == 1.0;
+    //assert pow(1.0, float::NaN) == 1.0;
+    assert pow(1.0, float::infinity) == 1.0;
+    //assert pow(1.0, float::neg_infinity) == 1.0;
+    assert pow(1.0, -3.0) == 1.0;
+    assert pow(1.0, -4.0) == 1.0;
+
+    assert pow(4.0, 0.0) == 1.0;
+    assert pow(0.0, 0.0) == 1.0;
+    assert pow(-0.0, 0.0) == 1.0;
+    //assert pow(float::NaN, 0.0) == 1.0;
+    assert pow(float::infinity, 0.0) == 1.0;
+    assert pow(float::neg_infinity, 0.0) == 1.0;
+    assert pow(-3.0, 0.0) == 1.0;
+    assert pow(-4.0, 0.0) == 1.0;
+
+    assert pow(4.0, -0.0) == 1.0;
+    assert pow(0.0, -0.0) == 1.0;
+    assert pow(-0.0, -0.0) == 1.0;
+    //assert pow(float::NaN, -0.0) == 1.0;
+    assert pow(float::infinity, -0.0) == 1.0;
+    assert pow(float::neg_infinity, -0.0) == 1.0;
+    assert pow(-3.0, -0.0) == 1.0;
+    assert pow(-4.0, -0.0) == 1.0;
+
+    assert float::isNaN(pow(-1.0, -1.5));
+    assert float::isNaN(pow(-1.0, 1.5));
+
+    assert float::isNaN(pow(-1.2, -1.5));
+    assert float::isNaN(pow(-1.2, 1.5));
+
+    assert pow(0.5, float::neg_infinity) == float::infinity;
+    assert pow(-0.5, float::neg_infinity) == float::infinity;
+
+    assert pow(1.5, float::neg_infinity) == 0.0;
+    assert pow(-1.5, float::neg_infinity) == 0.0;
+
+    assert pow(0.5, float::infinity) == 0.0;
+    assert pow(-0.5, float::infinity) == 0.0;
+
+    assert pow(-1.5, float::infinity) == float::infinity;
+    assert pow(1.5, float::infinity) == float::infinity;
+
+    assert pow(float::neg_infinity, -3.0) == -0.0;
+    assert pow(float::neg_infinity, -4.0) == 0.0;
+
+    assert pow(float::neg_infinity, 3.0) == float::neg_infinity;
+    assert pow(float::neg_infinity, 4.0) == float::infinity;
+
+    assert pow(float::infinity, -16.0) == 0.0;
+    assert pow(float::infinity, 16.0) == float::infinity;
+}
+
+// FIXME (1222): The commented-out tests give different results on windows
+#[test]
+fn test_exp_and_mod() {
+    assert exp(0.0) == 1.0;
+    assert exp(-0.0) == 1.0;
+    assert exp(float::neg_infinity) == 0.0;
+    assert exp(float::infinity) == float::infinity;
+
+    let d1: c_int = 1 as c_int;
+    assert frexp(0.0, d1) == 0.0;
+    assert frexp(-0.0, d1) == 0.0;
+    //assert frexp(float::infinity, d1) == float::infinity;
+    //assert frexp(float::neg_infinity, d1) == float::neg_infinity;
+    assert float::isNaN(frexp(float::NaN, d1));
+
+    let d2: float = 1.0;
+    assert modf(float::infinity, d2) == 0.0;
+    assert d2 == float::infinity;
+    assert modf(float::neg_infinity, d2) == -0.0;
+    assert d2 == float::neg_infinity;
+    assert float::isNaN(modf(float::NaN, d2));
+    assert float::isNaN(d2);
+}
+
+#[test]
+fn test_round_and_abs() {
+    assert abs(0.0) == 0.0;
+    assert abs(-0.0) == 0.0;
+    assert abs(float::infinity) == float::infinity;
+    assert abs(float::neg_infinity) == float::infinity;
+
+    assert abs(-2.5) == 2.5;
+    assert abs(2.5) == 2.5;
+
+    assert ceil(0.0) == 0.0;
+    assert ceil(-0.0) == -0.0;
+    assert ceil(float::infinity) == float::infinity;
+    assert ceil(float::neg_infinity) == float::neg_infinity;
+
+    assert ceil(1.9) == 2.0;
+    assert ceil(-1.9) == -1.0;
+
+    assert floor(0.0) == 0.0;
+    assert floor(-0.0) == -0.0;
+    assert floor(float::infinity) == float::infinity;
+    assert floor(float::neg_infinity) == float::neg_infinity;
+
+    assert floor(1.9) == 1.0;
+    assert floor(-1.9) == -2.0;
+
+    assert trunc(0.0) == 0.0;
+    assert trunc(-0.0) == -0.0;
+    assert trunc(float::infinity) == float::infinity;
+    assert trunc(float::neg_infinity) == float::neg_infinity;
+
+    assert trunc(1.5) == 1.0;
+    assert trunc(1.2) == 1.0;
+    assert trunc(1.0) == 1.0;
+    assert trunc(1.9) == 1.0;
+    assert trunc(-1.5) == -1.0;
+    assert trunc(-1.2) == -1.0;
+    assert trunc(-1.0) == -1.0;
+    assert trunc(-1.9) == -1.0;
+
+    assert round(0.0) == 0.0;
+    assert round(-0.0) == -0.0;
+    assert round(float::infinity) == float::infinity;
+    assert round(float::neg_infinity) == float::neg_infinity;
+
+    assert rint(0.0) == 0.0;
+    assert rint(-0.0) == -0.0;
+    assert rint(float::infinity) == float::infinity;
+    assert rint(float::neg_infinity) == float::neg_infinity;
+}
+
+#[test]
+fn test_hyp_trig() {
+    assert sinh(0.0) == 0.0;
+    assert sinh(-0.0) == 0.0;
+    assert sinh(float::infinity) == float::infinity;
+    assert sinh(float::neg_infinity) == float::neg_infinity;
+
+    assert cosh(0.0) == 1.0;
+    assert cosh(-0.0) == 1.0;
+    assert cosh(float::infinity) == float::infinity;
+    assert cosh(float::neg_infinity) == float::infinity;
+
+    assert tanh(0.0) == 0.0;
+    assert tanh(-0.0) == 0.0;
+    assert tanh(float::infinity) == 1.0;
+    assert tanh(float::neg_infinity) == -1.0;
+}
+
+#[test]
+fn test_sqrt() {
+    assert sqrt(9.0) == 3.0;
+    assert sqrt(4.0) == 2.0;
+    assert sqrt(1.0) == 1.0;
+    assert sqrt(0.0) == 0.0;
+}
+
+
+#[test]
+fn test_angle() {
+    fn angle(vec: (float, float)) -> float {
+        alt vec {
+          (0f, y) if y < 0f { 1.5 * consts::pi }
+          (0f, y) { 0.5 * consts::pi }
+          (x, y) { float::atan(y / x) }
+        }
+    }
+    assert angle((1f, 0f)) == 0f;
+    assert angle((1f, 1f)) == 0.25 * consts::pi;
+    assert angle((0f, 1f)) == 0.5 * consts::pi;
+}
+
+
+#[test]
+fn test_log_functions() {
+    assert ln(1.0) == 0.0;
+    assert log2(1.0) == 0.0;
+    assert log10(1.0) == 0.0;
+
+    // FIXME remove round-up due to valgrind weirdness
+    assert ceil(ln(consts::e)) == 1.0; /* ln(e) == 0.999.. under valgrind */
+    assert log2(2.0) == 1.0;
+    assert log10(10.0) == 1.0;
+
+    // FIXME remove round-up due to valgrind weirdness
+    assert ceil(ln(consts::e*consts::e*consts::e*consts::e)) == 4.0;
+    assert log2(256.0) == 8.0;
+    assert log10(1000.0) == 3.0;
+
+    assert ln(0.0) == float::neg_infinity;
+    assert log2(0.0) == float::neg_infinity;
+    assert log10(0.0) == float::neg_infinity;
+
+    assert ln(-0.0) == float::neg_infinity;
+    assert log2(-0.0) == float::neg_infinity;
+    assert log10(-0.0) == float::neg_infinity;
+
+    assert float::isNaN(ln(-1.0));
+    assert float::isNaN(log2(-1.0));
+    assert float::isNaN(log10(-1.0));
+
+    assert ln(float::infinity) == float::infinity;
+    assert log2(float::infinity) == float::infinity;
+    assert log10(float::infinity) == float::infinity;
+
+    assert ln1p(0.0) == 0.0;
+    assert ln1p(-0.0) == 0.0;
+    assert ln1p(-1.0) == float::neg_infinity;
+    assert float::isNaN(ln1p(-2.0f));
+    assert ln1p(float::infinity) == float::infinity;
+}
+
+*/

src/libcore/option.rs

@@ -84,6 +84,9 @@ fn may<T>(opt: t<T>, f: block(T)) {
     alt opt { none. {/* nothing */ } some(t) { f(t); } }
 }
 
+#[test]
+fn test() { let _x = some::<int>(10); }
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/libcore/ptr.rs

@@ -50,3 +50,20 @@ Function: null
 Create an unsafe null pointer
 */
 fn null<T>() -> *T unsafe { ret unsafe::reinterpret_cast(0u); }
+
+#[test]
+fn test() unsafe {
+    type pair = {mutable fst: int, mutable snd: int};
+    let p = {mutable fst: 10, mutable snd: 20};
+    let pptr: *mutable pair = mut_addr_of(p);
+    let iptr: *mutable int = unsafe::reinterpret_cast(pptr);
+    assert (*iptr == 10);;
+    *iptr = 30;
+    assert (*iptr == 30);
+    assert (p.fst == 30);;
+
+    *pptr = {mutable fst: 50, mutable snd: 60};
+    assert (*iptr == 50);
+    assert (p.fst == 50);
+    assert (p.snd == 60);
+}

src/libcore/result.rs

@@ -117,3 +117,22 @@ fn chain<T, U: copy, V: copy>(res: t<T, V>, op: block(T) -> t<U, V>)
       err(e) { err(e) }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    fn op1() -> result::t<int, str> { result::ok(666) }
+
+    fn op2(&&i: int) -> result::t<uint, str> { result::ok(i as uint + 1u) }
+
+    fn op3() -> result::t<int, str> { result::err("sadface") }
+
+    #[test]
+    fn chain_success() {
+        assert get(chain(op1(), op2)) == 667u;
+    }
+
+    #[test]
+    fn chain_failure() {
+        assert get_err(chain(op3(), op2)) == "sadface";
+    }
+}

src/libcore/str.rs

@@ -1112,3 +1112,464 @@ fn escape(s: str) -> str {
     loop_chars(s, { |c| r += escape_char(c); true });
     r
 }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_eq() {
+        assert (eq("", ""));
+        assert (eq("foo", "foo"));
+        assert (!eq("foo", "bar"));
+    }
+
+    #[test]
+    fn test_lteq() {
+        assert (lteq("", ""));
+        assert (lteq("", "foo"));
+        assert (lteq("foo", "foo"));
+        assert (!eq("foo", "bar"));
+    }
+
+    #[test]
+    fn test_bytes_len() {
+        assert (byte_len("") == 0u);
+        assert (byte_len("hello world") == 11u);
+        assert (byte_len("\x63") == 1u);
+        assert (byte_len("\xa2") == 2u);
+        assert (byte_len("\u03c0") == 2u);
+        assert (byte_len("\u2620") == 3u);
+        assert (byte_len("\U0001d11e") == 4u);
+    }
+
+    #[test]
+    fn test_index_and_rindex() {
+        assert (index("hello", 'e' as u8) == 1);
+        assert (index("hello", 'o' as u8) == 4);
+        assert (index("hello", 'z' as u8) == -1);
+        assert (rindex("hello", 'l' as u8) == 3);
+        assert (rindex("hello", 'h' as u8) == 0);
+        assert (rindex("hello", 'z' as u8) == -1);
+    }
+
+    #[test]
+    fn test_split() {
+        fn t(s: str, c: char, u: [str]) {
+            log(debug, "split: " + s);
+            let v = split(s, c as u8);
+            #debug("split to: ");
+            log(debug, v);
+            assert (vec::all2(v, u, { |a,b| a == b }));
+        }
+        t("abc.hello.there", '.', ["abc", "hello", "there"]);
+        t(".hello.there", '.', ["", "hello", "there"]);
+        t("...hello.there.", '.', ["", "", "", "hello", "there", ""]);
+    }
+
+    #[test]
+    fn test_splitn() {
+        fn t(s: str, c: char, n: uint, u: [str]) {
+            log(debug, "splitn: " + s);
+            let v = splitn(s, c as u8, n);
+            #debug("split to: ");
+            log(debug, v);
+            #debug("comparing vs. ");
+            log(debug, u);
+            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"]);
+        t("abc.hello.there", '.', 2u, ["abc", "hello", "there"]);
+        t("abc.hello.there", '.', 3u, ["abc", "hello", "there"]);
+        t(".hello.there", '.', 0u, [".hello.there"]);
+        t(".hello.there", '.', 1u, ["", "hello.there"]);
+        t("...hello.there.", '.', 3u, ["", "", "", "hello.there."]);
+        t("...hello.there.", '.', 5u, ["", "", "", "hello", "there", ""]);
+    }
+
+    #[test]
+    fn test_split_str() {
+        fn t(s: str, sep: str, i: int, k: str) {
+            let v = split_str(s, sep);
+            assert eq(v[i], k);
+        }
+
+        //FIXME: should behave like split and split_char:
+        //assert ["", "XXX", "YYY", ""] == split_str(".XXX.YYY.", ".");
+
+        t("abc::hello::there", "::", 0, "abc");
+        t("abc::hello::there", "::", 1, "hello");
+        t("abc::hello::there", "::", 2, "there");
+        t("::hello::there", "::", 0, "hello");
+        t("hello::there::", "::", 2, "");
+        t("::hello::there::", "::", 2, "");
+        t("ประเทศไทย中华Việt Nam", "中华", 0, "ประเทศไทย");
+        t("ประเทศไทย中华Việt Nam", "中华", 1, "Việt Nam");
+    }
+
+    #[test]
+    fn test_split_func () {
+        let data = "ประเทศไทย中华Việt Nam";
+        assert ["ประเทศไทย中", "Việt Nam"]
+            == split_func (data, {|cc| cc == '华'});
+
+        assert ["", "", "XXX", "YYY", ""]
+            == split_func("zzXXXzYYYz", char::is_lowercase);
+
+        assert ["zz", "", "", "z", "", "", "z"]
+            == split_func("zzXXXzYYYz", char::is_uppercase);
+
+        assert ["",""] == split_func("z", {|cc| cc == 'z'});
+        assert [""] == split_func("", {|cc| cc == 'z'});
+        assert ["ok"] == split_func("ok", {|cc| cc == 'z'});
+    }
+
+    #[test]
+    fn test_split_char () {
+        let data = "ประเทศไทย中华Việt Nam";
+        assert ["ประเทศไทย中", "Việt Nam"]
+            == split_char(data, '华');
+
+        assert ["", "", "XXX", "YYY", ""]
+            == split_char("zzXXXzYYYz", 'z');
+        assert ["",""] == split_char("z", 'z');
+        assert [""] == split_char("", 'z');
+        assert ["ok"] == split_char("ok", 'z');
+    }
+
+    #[test]
+    fn test_lines () {
+        let lf = "\nMary had a little lamb\nLittle lamb\n";
+        let crlf = "\r\nMary had a little lamb\r\nLittle lamb\r\n";
+
+        assert ["", "Mary had a little lamb", "Little lamb", ""]
+            == lines(lf);
+
+        assert ["", "Mary had a little lamb", "Little lamb", ""]
+            == lines_any(lf);
+
+        assert ["\r", "Mary had a little lamb\r", "Little lamb\r", ""]
+            == lines(crlf);
+
+        assert ["", "Mary had a little lamb", "Little lamb", ""]
+            == lines_any(crlf);
+
+        assert [""] == lines    ("");
+        assert [""] == lines_any("");
+        assert ["",""] == lines    ("\n");
+        assert ["",""] == lines_any("\n");
+        assert ["banana"] == lines    ("banana");
+        assert ["banana"] == lines_any("banana");
+    }
+
+    #[test]
+    fn test_words () {
+        let data = "\nMary had a little lamb\nLittle lamb\n";
+        assert ["Mary","had","a","little","lamb","Little","lamb"]
+            == words(data);
+
+        assert ["ok"] == words("ok");
+        assert [] == words("");
+    }
+
+    #[test]
+    fn test_find() {
+        fn t(haystack: str, needle: str, i: int) {
+            let j: int = find(haystack, needle);
+            log(debug, "searched for " + needle);
+            log(debug, j);
+            assert (i == j);
+        }
+        t("this is a simple", "is a", 5);
+        t("this is a simple", "is z", -1);
+        t("this is a simple", "", 0);
+        t("this is a simple", "simple", 10);
+        t("this", "simple", -1);
+    }
+
+    #[test]
+    fn test_substr() {
+        fn t(a: str, b: str, start: int) {
+            assert (eq(substr(a, start as uint, byte_len(b)), b));
+        }
+        t("hello", "llo", 2);
+        t("hello", "el", 1);
+        t("substr should not be a challenge", "not", 14);
+    }
+
+    #[test]
+    fn test_concat() {
+        fn t(v: [str], s: str) { assert (eq(concat(v), s)); }
+        t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
+        let v: [str] = [];
+        t(v, "");
+        t(["hi"], "hi");
+    }
+
+    #[test]
+    fn test_connect() {
+        fn t(v: [str], sep: str, s: str) {
+            assert (eq(connect(v, sep), s));
+        }
+        t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
+        let v: [str] = [];
+        t(v, " ", "");
+        t(["hi"], " ", "hi");
+    }
+
+    #[test]
+    fn test_to_upper() {
+        // to_upper doesn't understand unicode yet,
+        // but we need to at least preserve it
+
+        let unicode = "\u65e5\u672c";
+        let input = "abcDEF" + unicode + "xyz:.;";
+        let expected = "ABCDEF" + unicode + "XYZ:.;";
+        let actual = to_upper(input);
+        assert (eq(expected, actual));
+    }
+
+    #[test]
+    fn test_slice() {
+        assert (eq("ab", slice("abc", 0u, 2u)));
+        assert (eq("bc", slice("abc", 1u, 3u)));
+        assert (eq("", slice("abc", 1u, 1u)));
+        fn a_million_letter_a() -> str {
+            let i = 0;
+            let rs = "";
+            while i < 100000 { rs += "aaaaaaaaaa"; i += 1; }
+            ret rs;
+        }
+        fn half_a_million_letter_a() -> str {
+            let i = 0;
+            let rs = "";
+            while i < 100000 { rs += "aaaaa"; i += 1; }
+            ret rs;
+        }
+        assert (eq(half_a_million_letter_a(),
+                        slice(a_million_letter_a(), 0u, 500000u)));
+    }
+
+    #[test]
+    fn test_starts_with() {
+        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() {
+        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() {
+        assert (is_empty(""));
+        assert (!is_empty("a"));
+    }
+
+    #[test]
+    fn test_is_not_empty() {
+        assert (is_not_empty("a"));
+        assert (!is_not_empty(""));
+    }
+
+    #[test]
+    fn test_replace() {
+        let a = "a";
+        check (is_not_empty(a));
+        assert (replace("", a, "b") == "");
+        assert (replace("a", a, "b") == "b");
+        assert (replace("ab", a, "b") == "bb");
+        let test = "test";
+        check (is_not_empty(test));
+        assert (replace(" test test ", test, "toast") == " toast toast ");
+        assert (replace(" test test ", test, "") == "   ");
+    }
+
+    #[test]
+    fn test_char_slice() {
+        assert (eq("ab", char_slice("abc", 0u, 2u)));
+        assert (eq("bc", char_slice("abc", 1u, 3u)));
+        assert (eq("", char_slice("abc", 1u, 1u)));
+        assert (eq("\u65e5", char_slice("\u65e5\u672c", 0u, 1u)));
+
+        let data = "ประเทศไทย中华";
+        assert (eq("ป", char_slice(data, 0u, 1u)));
+        assert (eq("ร", char_slice(data, 1u, 2u)));
+        assert (eq("华", char_slice(data, 10u, 11u)));
+        assert (eq("", char_slice(data, 1u, 1u)));
+
+        fn a_million_letter_X() -> str {
+            let i = 0;
+            let rs = "";
+            while i < 100000 { rs += "华华华华华华华华华华"; i += 1; }
+            ret rs;
+        }
+        fn half_a_million_letter_X() -> str {
+            let i = 0;
+            let rs = "";
+            while i < 100000 { rs += "华华华华华"; i += 1; }
+            ret rs;
+        }
+        assert (eq(half_a_million_letter_X(),
+                        char_slice(a_million_letter_X(), 0u, 500000u)));
+    }
+
+    #[test]
+    fn test_trim_left() {
+        assert (trim_left("") == "");
+        assert (trim_left("a") == "a");
+        assert (trim_left("    ") == "");
+        assert (trim_left("     blah") == "blah");
+        assert (trim_left("   \u3000  wut") == "wut");
+        assert (trim_left("hey ") == "hey ");
+    }
+
+    #[test]
+    fn test_trim_right() {
+        assert (trim_right("") == "");
+        assert (trim_right("a") == "a");
+        assert (trim_right("    ") == "");
+        assert (trim_right("blah     ") == "blah");
+        assert (trim_right("wut   \u3000  ") == "wut");
+        assert (trim_right(" hey") == " hey");
+    }
+
+    #[test]
+    fn test_trim() {
+        assert (trim("") == "");
+        assert (trim("a") == "a");
+        assert (trim("    ") == "");
+        assert (trim("    blah     ") == "blah");
+        assert (trim("\nwut   \u3000  ") == "wut");
+        assert (trim(" hey dude ") == "hey dude");
+    }
+
+    #[test]
+    fn test_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() {
+        assert (is_ascii(""));
+        assert (is_ascii("a"));
+        assert (!is_ascii("\u2009"));
+    }
+
+    #[test]
+    fn test_shift_byte() {
+        let s = "ABC";
+        let b = shift_byte(s);
+        assert (s == "BC");
+        assert (b == 65u8);
+    }
+
+    #[test]
+    fn test_pop_byte() {
+        let s = "ABC";
+        let b = pop_byte(s);
+        assert (s == "AB");
+        assert (b == 67u8);
+    }
+
+    #[test]
+    fn test_unsafe_from_bytes() {
+        let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
+        let b = unsafe_from_bytes(a);
+        assert (b == "AAAAAAA");
+    }
+
+    #[test]
+    fn test_from_cstr() unsafe {
+        let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
+        let b = vec::to_ptr(a);
+        let c = from_cstr(b);
+        assert (c == "AAAAAAA");
+    }
+
+    #[test]
+    fn test_as_buf() unsafe {
+        let a = "Abcdefg";
+        let b = as_buf(a, {|buf| assert (*buf == 65u8); 100 });
+        assert (b == 100);
+    }
+
+    #[test]
+    fn test_as_buf_small() unsafe {
+        let a = "A";
+        let b = as_buf(a, {|buf| assert (*buf == 65u8); 100 });
+        assert (b == 100);
+    }
+
+    #[test]
+    fn test_as_buf2() unsafe {
+        let s = "hello";
+        let sb = as_buf(s, {|b| b });
+        let s_cstr = from_cstr(sb);
+        assert (eq(s_cstr, s));
+    }
+
+    #[test]
+    fn vec_str_conversions() {
+        let s1: str = "All mimsy were the borogoves";
+
+        let v: [u8] = bytes(s1);
+        let s2: str = unsafe_from_bytes(v);
+        let i: uint = 0u;
+        let n1: uint = byte_len(s1);
+        let n2: uint = vec::len::<u8>(v);
+        assert (n1 == n2);
+        while i < n1 {
+            let a: u8 = s1[i];
+            let b: u8 = s2[i];
+            log(debug, a);
+            log(debug, b);
+            assert (a == b);
+            i += 1u;
+        }
+    }
+
+    #[test]
+    fn test_contains() {
+        assert contains("abcde", "bcd");
+        assert contains("abcde", "abcd");
+        assert contains("abcde", "bcde");
+        assert contains("abcde", "");
+        assert contains("", "");
+        assert !contains("abcde", "def");
+        assert !contains("", "a");
+    }
+
+    #[test]
+    fn test_iter_chars() {
+        let i = 0;
+        iter_chars("x\u03c0y") {|ch|
+            alt i {
+              0 { assert ch == 'x'; }
+              1 { assert ch == '\u03c0'; }
+              2 { assert ch == 'y'; }
+            }
+            i += 1;
+        }
+    }
+
+    #[test]
+    fn test_escape() {
+        assert(escape("abcdef") == "abcdef");
+        assert(escape("abc\\def") == "abc\\\\def");
+        assert(escape("abc\ndef") == "abc\\ndef");
+        assert(escape("abc\"def") == "abc\\\"def");
+    }
+}

src/libcore/sys.rs

@@ -122,6 +122,60 @@ fn set_min_stack(size: uint) {
     rustrt::set_min_stack(size);
 }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn last_os_error() {
+        log(debug, last_os_error());
+    }
+
+    #[test]
+    fn size_of_basic() {
+        assert size_of::<u8>() == 1u;
+        assert size_of::<u16>() == 2u;
+        assert size_of::<u32>() == 4u;
+        assert size_of::<u64>() == 8u;
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86")]
+    #[cfg(target_arch = "arm")]
+    fn size_of_32() {
+        assert size_of::<uint>() == 4u;
+        assert size_of::<*uint>() == 4u;
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn size_of_64() {
+        assert size_of::<uint>() == 8u;
+        assert size_of::<*uint>() == 8u;
+    }
+
+    #[test]
+    fn align_of_basic() {
+        assert align_of::<u8>() == 1u;
+        assert align_of::<u16>() == 2u;
+        assert align_of::<u32>() == 4u;
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86")]
+    #[cfg(target_arch = "arm")]
+    fn align_of_32() {
+        assert align_of::<uint>() == 4u;
+        assert align_of::<*uint>() == 4u;
+    }
+
+    #[test]
+    #[cfg(target_arch = "x86_64")]
+    fn align_of_64() {
+        assert align_of::<uint>() == 8u;
+        assert align_of::<*uint>() == 8u;
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/libcore/task.rs

@@ -374,6 +374,85 @@ fn try<T:send>(+f: fn~() -> T) -> result::t<T,()> {
     }
 }
 
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_sleep() { sleep(1000000u); }
+
+    // FIXME: Leaks on windows
+    #[test]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_unsupervise() {
+        fn f() { unsupervise(); fail; }
+        spawn {|| f();};
+    }
+
+    #[test]
+    fn test_lib_spawn() {
+        fn foo() { #error("Hello, World!"); }
+        spawn {|| foo();};
+    }
+
+    #[test]
+    fn test_lib_spawn2() {
+        fn foo(x: int) { assert (x == 42); }
+        spawn {|| foo(42);};
+    }
+
+    #[test]
+    fn test_join_chan() {
+        fn winner() { }
+
+        let t = spawn_joinable {|| winner();};
+        alt join(t) {
+          tr_success. {/* yay! */ }
+          _ { fail "invalid task status received" }
+        }
+    }
+
+    // FIXME: Leaks on windows
+    #[test]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_join_chan_fail() {
+        fn failer() { unsupervise(); fail }
+
+        let t = spawn_joinable {|| failer();};
+        alt join(t) {
+          tr_failure. {/* yay! */ }
+          _ { fail "invalid task status received" }
+        }
+    }
+
+    #[test]
+    fn spawn_polymorphic() {
+        fn foo<T:send>(x: T) { log(error, x); }
+        spawn {|| foo(true);};
+        spawn {|| foo(42);};
+    }
+
+    #[test]
+    fn try_success() {
+        alt try {||
+            "Success!"
+        } {
+            result::ok("Success!") { }
+            _ { fail; }
+        }
+    }
+
+    #[test]
+    #[ignore(cfg(target_os = "win32"))]
+    fn try_fail() {
+        alt try {||
+            fail
+        } {
+            result::err(()) { }
+            _ { fail; }
+        }
+    }
+}
+
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/libcore/uint.rs

@@ -252,6 +252,116 @@ Convert to a string
 */
 fn str(i: uint) -> str { ret to_str(i, 10u); }
 
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_from_str() {
+        assert (uint::from_str("0") == 0u);
+        assert (uint::from_str("3") == 3u);
+        assert (uint::from_str("10") == 10u);
+        assert (uint::from_str("123456789") == 123456789u);
+        assert (uint::from_str("00100") == 100u);
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_from_str_fail_1() {
+        uint::from_str(" ");
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_from_str_fail_2() {
+        uint::from_str("x");
+    }
+
+    #[test]
+    fn test_parse_buf() {
+        import str::bytes;
+        assert (uint::parse_buf(bytes("123"), 10u) == 123u);
+        assert (uint::parse_buf(bytes("1001"), 2u) == 9u);
+        assert (uint::parse_buf(bytes("123"), 8u) == 83u);
+        assert (uint::parse_buf(bytes("123"), 16u) == 291u);
+        assert (uint::parse_buf(bytes("ffff"), 16u) == 65535u);
+        assert (uint::parse_buf(bytes("z"), 36u) == 35u);
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_parse_buf_fail_1() {
+        uint::parse_buf(str::bytes("Z"), 10u);
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_parse_buf_fail_2() {
+        uint::parse_buf(str::bytes("_"), 2u);
+    }
+
+    #[test]
+    fn test_next_power_of_two() {
+        assert (uint::next_power_of_two(0u) == 0u);
+        assert (uint::next_power_of_two(1u) == 1u);
+        assert (uint::next_power_of_two(2u) == 2u);
+        assert (uint::next_power_of_two(3u) == 4u);
+        assert (uint::next_power_of_two(4u) == 4u);
+        assert (uint::next_power_of_two(5u) == 8u);
+        assert (uint::next_power_of_two(6u) == 8u);
+        assert (uint::next_power_of_two(7u) == 8u);
+        assert (uint::next_power_of_two(8u) == 8u);
+        assert (uint::next_power_of_two(9u) == 16u);
+        assert (uint::next_power_of_two(10u) == 16u);
+        assert (uint::next_power_of_two(11u) == 16u);
+        assert (uint::next_power_of_two(12u) == 16u);
+        assert (uint::next_power_of_two(13u) == 16u);
+        assert (uint::next_power_of_two(14u) == 16u);
+        assert (uint::next_power_of_two(15u) == 16u);
+        assert (uint::next_power_of_two(16u) == 16u);
+        assert (uint::next_power_of_two(17u) == 32u);
+        assert (uint::next_power_of_two(18u) == 32u);
+        assert (uint::next_power_of_two(19u) == 32u);
+        assert (uint::next_power_of_two(20u) == 32u);
+        assert (uint::next_power_of_two(21u) == 32u);
+        assert (uint::next_power_of_two(22u) == 32u);
+        assert (uint::next_power_of_two(23u) == 32u);
+        assert (uint::next_power_of_two(24u) == 32u);
+        assert (uint::next_power_of_two(25u) == 32u);
+        assert (uint::next_power_of_two(26u) == 32u);
+        assert (uint::next_power_of_two(27u) == 32u);
+        assert (uint::next_power_of_two(28u) == 32u);
+        assert (uint::next_power_of_two(29u) == 32u);
+        assert (uint::next_power_of_two(30u) == 32u);
+        assert (uint::next_power_of_two(31u) == 32u);
+        assert (uint::next_power_of_two(32u) == 32u);
+        assert (uint::next_power_of_two(33u) == 64u);
+        assert (uint::next_power_of_two(34u) == 64u);
+        assert (uint::next_power_of_two(35u) == 64u);
+        assert (uint::next_power_of_two(36u) == 64u);
+        assert (uint::next_power_of_two(37u) == 64u);
+        assert (uint::next_power_of_two(38u) == 64u);
+        assert (uint::next_power_of_two(39u) == 64u);
+    }
+
+    #[test]
+    fn test_overflows() {
+        assert (uint::max_value > 0u);
+        assert (uint::min_value <= 0u);
+        assert (uint::min_value + uint::max_value + 1u == 0u);
+    }
+
+    #[test]
+    fn test_div() {
+        assert(uint::div_floor(3u, 4u) == 0u);
+        assert(uint::div_ceil(3u, 4u)  == 1u);
+        assert(uint::div_round(3u, 4u) == 1u);
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/libcore/unsafe.rs

@@ -4,6 +4,8 @@ Module: unsafe
 Unsafe operations
 */
 
+export reinterpret_cast, leak;
+
 #[abi = "rust-intrinsic"]
 native mod rusti {
     fn cast<T, U>(src: T) -> U;
@@ -39,3 +41,19 @@ can be used for various acts of magick, particularly when using
 reinterpret_cast on managed pointer types.
 */
 unsafe fn leak<T>(-thing: T) { rustrt::leak(thing); }
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_reinterpret_cast() unsafe {
+        assert reinterpret_cast(1) == 1u;
+    }
+
+    #[test]
+    #[should_fail]
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_reinterpret_cast_wrong_size() unsafe {
+        let _i: uint = reinterpret_cast(0u8);
+    }
+}

src/libcore/vec.rs

@@ -981,6 +981,524 @@ mod u8 {
     }
 }
 
+#[cfg(test)]
+mod tests {
+
+    fn square(n: uint) -> uint { ret n * n; }
+
+    fn square_ref(&&n: uint) -> uint { ret n * n; }
+
+    pure fn is_three(&&n: uint) -> bool { ret n == 3u; }
+
+    pure fn is_odd(&&n: uint) -> bool { ret n % 2u == 1u; }
+
+    pure fn is_equal(&&x: uint, &&y:uint) -> bool { ret x == y; }
+
+    fn square_if_odd(&&n: uint) -> option::t<uint> {
+        ret if n % 2u == 1u { some(n * n) } else { none };
+    }
+
+    fn add(&&x: uint, &&y: uint) -> uint { ret x + y; }
+
+    #[test]
+    fn test_unsafe_ptrs() unsafe {
+        // Test on-stack copy-from-buf.
+        let a = [1, 2, 3];
+        let ptr = to_ptr(a);
+        let b = unsafe::from_buf(ptr, 3u);
+        assert (len(b) == 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 = to_ptr(c);
+        let d = unsafe::from_buf(ptr, 5u);
+        assert (len(d) == 5u);
+        assert (d[0] == 1);
+        assert (d[1] == 2);
+        assert (d[2] == 3);
+        assert (d[3] == 4);
+        assert (d[4] == 5);
+    }
+
+    #[test]
+    fn test_init_fn() {
+        // Test on-stack init_fn.
+        let v = init_fn(square, 3u);
+        assert (len(v) == 3u);
+        assert (v[0] == 0u);
+        assert (v[1] == 1u);
+        assert (v[2] == 4u);
+
+        // Test on-heap init_fn.
+        v = init_fn(square, 5u);
+        assert (len(v) == 5u);
+        assert (v[0] == 0u);
+        assert (v[1] == 1u);
+        assert (v[2] == 4u);
+        assert (v[3] == 9u);
+        assert (v[4] == 16u);
+    }
+
+    #[test]
+    fn test_init_elt() {
+        // Test on-stack init_elt.
+        let v = init_elt(10u, 2u);
+        assert (len(v) == 2u);
+        assert (v[0] == 10u);
+        assert (v[1] == 10u);
+
+        // Test on-heap init_elt.
+        v = init_elt(20u, 6u);
+        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() {
+        assert (is_empty::<int>([]));
+        assert (!is_empty([0]));
+    }
+
+    #[test]
+    fn test_is_not_empty() {
+        assert (is_not_empty([0]));
+        assert (!is_not_empty::<int>([]));
+    }
+
+    #[test]
+    fn test_head() {
+        let a = [11, 12];
+        check (is_not_empty(a));
+        assert (head(a) == 11);
+    }
+
+    #[test]
+    fn test_tail() {
+        let a = [11];
+        check (is_not_empty(a));
+        assert (tail(a) == []);
+
+        a = [11, 12];
+        check (is_not_empty(a));
+        assert (tail(a) == [12]);
+    }
+
+    #[test]
+    fn test_last() {
+        let n = last([]);
+        assert (n == none);
+        n = last([1, 2, 3]);
+        assert (n == some(3));
+        n = last([1, 2, 3, 4, 5]);
+        assert (n == some(5));
+    }
+
+    #[test]
+    fn test_slice() {
+        // Test on-stack -> on-stack slice.
+        let v = slice([1, 2, 3], 1u, 3u);
+        assert (len(v) == 2u);
+        assert (v[0] == 2);
+        assert (v[1] == 3);
+
+        // Test on-heap -> on-stack slice.
+        v = slice([1, 2, 3, 4, 5], 0u, 3u);
+        assert (len(v) == 3u);
+        assert (v[0] == 1);
+        assert (v[1] == 2);
+        assert (v[2] == 3);
+
+        // Test on-heap -> on-heap slice.
+        v = slice([1, 2, 3, 4, 5, 6], 1u, 6u);
+        assert (len(v) == 5u);
+        assert (v[0] == 2);
+        assert (v[1] == 3);
+        assert (v[2] == 4);
+        assert (v[3] == 5);
+        assert (v[4] == 6);
+    }
+
+    #[test]
+    fn test_pop() {
+        // Test on-stack pop.
+        let v = [1, 2, 3];
+        let e = pop(v);
+        assert (len(v) == 2u);
+        assert (v[0] == 1);
+        assert (v[1] == 2);
+        assert (e == 3);
+
+        // Test on-heap pop.
+        v = [1, 2, 3, 4, 5];
+        e = pop(v);
+        assert (len(v) == 4u);
+        assert (v[0] == 1);
+        assert (v[1] == 2);
+        assert (v[2] == 3);
+        assert (v[3] == 4);
+        assert (e == 5);
+    }
+
+    #[test]
+    fn test_push() {
+        // Test on-stack push().
+        let v = [];
+        push(v, 1);
+        assert (len(v) == 1u);
+        assert (v[0] == 1);
+
+        // Test on-heap push().
+        push(v, 2);
+        assert (len(v) == 2u);
+        assert (v[0] == 1);
+        assert (v[1] == 2);
+    }
+
+    #[test]
+    fn test_grow() {
+        // Test on-stack grow().
+        let v = [];
+        grow(v, 2u, 1);
+        assert (len(v) == 2u);
+        assert (v[0] == 1);
+        assert (v[1] == 1);
+
+        // Test on-heap grow().
+        grow(v, 3u, 2);
+        assert (len(v) == 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 v = [];
+        grow_fn(v, 3u, square);
+        assert (len(v) == 3u);
+        assert (v[0] == 0u);
+        assert (v[1] == 1u);
+        assert (v[2] == 4u);
+    }
+
+    #[test]
+    fn test_grow_set() {
+        let v = [mutable 1, 2, 3];
+        grow_set(v, 4u, 4, 5);
+        assert (len(v) == 5u);
+        assert (v[0] == 1);
+        assert (v[1] == 2);
+        assert (v[2] == 3);
+        assert (v[3] == 4);
+        assert (v[4] == 5);
+    }
+
+    #[test]
+    fn test_map() {
+        // Test on-stack map.
+        let v = [1u, 2u, 3u];
+        let w = map(v, square_ref);
+        assert (len(w) == 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);
+        assert (len(w) == 5u);
+        assert (w[0] == 1u);
+        assert (w[1] == 4u);
+        assert (w[2] == 9u);
+        assert (w[3] == 16u);
+        assert (w[4] == 25u);
+    }
+
+    #[test]
+    fn test_map2() {
+        fn times(&&x: int, &&y: int) -> int { ret x * y; }
+        let f = times;
+        let v0 = [1, 2, 3, 4, 5];
+        let v1 = [5, 4, 3, 2, 1];
+        let u = map2::<int, int, int>(v0, v1, f);
+        let i = 0;
+        while i < 5 { assert (v0[i] * v1[i] == u[i]); i += 1; }
+    }
+
+    #[test]
+    fn test_filter_map() {
+        // Test on-stack filter-map.
+        let v = [1u, 2u, 3u];
+        let w = filter_map(v, square_if_odd);
+        assert (len(w) == 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);
+        assert (len(w) == 3u);
+        assert (w[0] == 1u);
+        assert (w[1] == 9u);
+        assert (w[2] == 25u);
+
+        fn halve(&&i: int) -> option::t<int> {
+            if i % 2 == 0 {
+                ret option::some::<int>(i / 2);
+            } else { ret option::none::<int>; }
+        }
+        fn halve_for_sure(&&i: int) -> int { ret i / 2; }
+        let all_even: [int] = [0, 2, 8, 6];
+        let all_odd1: [int] = [1, 7, 3];
+        let all_odd2: [int] = [];
+        let mix: [int] = [9, 2, 6, 7, 1, 0, 0, 3];
+        let mix_dest: [int] = [1, 3, 0, 0];
+        assert (filter_map(all_even, halve) == map(all_even, halve_for_sure));
+        assert (filter_map(all_odd1, halve) == []);
+        assert (filter_map(all_odd2, halve) == []);
+        assert (filter_map(mix, halve) == mix_dest);
+    }
+
+    #[test]
+    fn test_filter() {
+        assert filter([1u, 2u, 3u], is_odd) == [1u, 3u];
+        assert filter([1u, 2u, 4u, 8u, 16u], is_three) == [];
+    }
+
+    #[test]
+    fn test_foldl() {
+        // Test on-stack fold.
+        let v = [1u, 2u, 3u];
+        let sum = foldl(0u, v, add);
+        assert (sum == 6u);
+
+        // Test on-heap fold.
+        v = [1u, 2u, 3u, 4u, 5u];
+        sum = foldl(0u, v, add);
+        assert (sum == 15u);
+    }
+
+    #[test]
+    fn test_foldl2() {
+        fn sub(&&a: int, &&b: int) -> int {
+            a - b
+        }
+        let v = [1, 2, 3, 4];
+        let sum = foldl(0, v, sub);
+        assert sum == -10;
+    }
+
+    #[test]
+    fn test_foldr() {
+        fn sub(&&a: int, &&b: int) -> int {
+            a - b
+        }
+        let v = [1, 2, 3, 4];
+        let sum = foldr(v, 0, sub);
+        assert sum == -2;
+    }
+
+    #[test]
+    fn test_iter_empty() {
+        let i = 0;
+        iter::<int>([], { |_v| i += 1 });
+        assert i == 0;
+    }
+
+    #[test]
+    fn test_iter_nonempty() {
+        let i = 0;
+        iter([1, 2, 3], { |v| i += v });
+        assert i == 6;
+    }
+
+    #[test]
+    fn test_iteri() {
+        let i = 0;
+        iteri([1, 2, 3], { |j, v|
+            if i == 0 { assert v == 1; }
+            assert j + 1u == v as uint;
+            i += v;
+        });
+        assert i == 6;
+    }
+
+    #[test]
+    fn test_riter_empty() {
+        let i = 0;
+        riter::<int>([], { |_v| i += 1 });
+        assert i == 0;
+    }
+
+    #[test]
+    fn test_riter_nonempty() {
+        let i = 0;
+        riter([1, 2, 3], { |v|
+            if i == 0 { assert v == 3; }
+            i += v
+        });
+        assert i == 6;
+    }
+
+    #[test]
+    fn test_riteri() {
+        let i = 0;
+        riteri([0, 1, 2], { |j, v|
+            if i == 0 { assert v == 2; }
+            assert j == v as uint;
+            i += v;
+        });
+        assert i == 3;
+    }
+
+    #[test]
+    fn test_permute() {
+        let results: [[int]];
+
+        results = [];
+        permute([]) {|v| results += [v]; }
+        assert results == [[]];
+
+        results = [];
+        permute([7]) {|v| results += [v]; }
+        assert results == [[7]];
+
+        results = [];
+        permute([1,1]) {|v| results += [v]; }
+        assert results == [[1,1],[1,1]];
+
+        results = [];
+        permute([5,2,0]) {|v| results += [v]; }
+        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() {
+        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));
+
+        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() {
+
+        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));
+
+        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]
+    fn test_zip_unzip() {
+        let v1 = [1, 2, 3];
+        let v2 = [4, 5, 6];
+
+        check (same_length(v1, v2)); // Silly, but what else can we do?
+        let z1 = zip(v1, v2);
+
+        assert ((1, 4) == z1[0]);
+        assert ((2, 5) == z1[1]);
+        assert ((3, 6) == z1[2]);
+
+        let (left, right) = unzip(z1);
+
+        assert ((1, 4) == (left[0], right[0]));
+        assert ((2, 5) == (left[1], right[1]));
+        assert ((3, 6) == (left[2], right[2]));
+    }
+
+    #[test]
+    fn test_position() {
+        let v1: [int] = [1, 2, 3, 3, 2, 5];
+        assert (position(1, v1) == option::some::<uint>(0u));
+        assert (position(2, v1) == option::some::<uint>(1u));
+        assert (position(5, v1) == option::some::<uint>(5u));
+        assert (position(4, v1) == option::none::<uint>);
+    }
+
+    #[test]
+    fn test_position_pred() {
+        fn less_than_three(&&i: int) -> bool { ret i < 3; }
+        fn is_eighteen(&&i: int) -> bool { ret i == 18; }
+        let v1: [int] = [5, 4, 3, 2, 1];
+        assert position_pred(v1, less_than_three) == option::some::<uint>(3u);
+        assert position_pred(v1, is_eighteen) == option::none::<uint>;
+    }
+
+    #[test]
+    fn reverse_and_reversed() {
+        let v: [mutable int] = [mutable 10, 20];
+        assert (v[0] == 10);
+        assert (v[1] == 20);
+        reverse(v);
+        assert (v[0] == 20);
+        assert (v[1] == 10);
+        let v2 = reversed::<int>([10, 20]);
+        assert (v2[0] == 20);
+        assert (v2[1] == 10);
+        v[0] = 30;
+        assert (v2[0] == 20);
+        // Make sure they work with 0-length vectors too.
+
+        let v4 = reversed::<int>([]);
+        assert (v4 == []);
+        let v3: [mutable int] = [mutable];
+        reverse::<int>(v3);
+    }
+
+    #[test]
+    fn reversed_mut() {
+        let v2 = reversed::<int>([mutable 10, 20]);
+        assert (v2[0] == 20);
+        assert (v2[1] == 10);
+    }
+
+    #[test]
+    fn test_init() {
+        let v = init([1, 2, 3]);
+        assert v == [1, 2];
+    }
+
+    #[test]
+    // FIXME: Windows can't undwind
+    #[ignore(cfg(target_os = "win32"))]
+    fn test_init_empty() {
+
+        let r = task::join(
+            task::spawn_joinable {||
+                task::unsupervise();
+                init::<int>([]);
+            });
+        assert r == task::tr_failure
+    }
+
+    #[test]
+    fn test_concat() {
+        assert concat([[1], [2,3]]) == [1, 2, 3];
+    }
+
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/test/stdtest/bool.rs

@@ -1,25 +0,0 @@
-import core::*;
-
-use std;
-
-import bool;
-
-#[test]
-fn test_bool_from_str() {
-    bool::all_values { |v|
-        assert v == bool::from_str(bool::to_str(v))
-    }
-}
-
-#[test]
-fn test_bool_to_str() {
-    assert bool::to_str(false) == "false";
-    assert bool::to_str(true) == "true";
-}
-
-#[test]
-fn test_bool_to_bit() {
-    bool::all_values { |v|
-        assert bool::to_bit(v) == if bool::is_true(v) { 1u8 } else { 0u8 };
-    }
-}

src/test/stdtest/box.rs

@@ -1,14 +0,0 @@
-import core::*;
-
-use std;
-import box;
-
-#[test]
-fn test() {
-    let x = @3;
-    let y = @3;
-    assert (box::ptr_eq::<int>(x, x));
-    assert (box::ptr_eq::<int>(y, y));
-    assert (!box::ptr_eq::<int>(x, y));
-    assert (!box::ptr_eq::<int>(y, x));
-}

src/test/stdtest/char.rs

@@ -1,78 +0,0 @@
-import core::*;
-
-use std;
-import char;
-
-#[test]
-fn test_is_lowercase() {
-    assert char::is_lowercase('a');
-    assert char::is_lowercase('ö');
-    assert char::is_lowercase('ß');
-    assert !char::is_lowercase('Ü');
-    assert !char::is_lowercase('P');
-}
-
-#[test]
-fn test_is_uppercase() {
-    assert !char::is_uppercase('h');
-    assert !char::is_uppercase('ä');
-    assert !char::is_uppercase('ß');
-    assert char::is_uppercase('Ö');
-    assert char::is_uppercase('T');
-}
-
-#[test]
-fn test_is_whitespace() {
-    assert char::is_whitespace(' ');
-    assert char::is_whitespace('\u2007');
-    assert char::is_whitespace('\t');
-    assert char::is_whitespace('\n');
-
-    assert !char::is_whitespace('a');
-    assert !char::is_whitespace('_');
-    assert !char::is_whitespace('\u0000');
-}
-
-#[test]
-fn test_to_digit() {
-    assert (char::to_digit('0') == 0u8);
-    assert (char::to_digit('1') == 1u8);
-    assert (char::to_digit('2') == 2u8);
-    assert (char::to_digit('9') == 9u8);
-    assert (char::to_digit('a') == 10u8);
-    assert (char::to_digit('A') == 10u8);
-    assert (char::to_digit('b') == 11u8);
-    assert (char::to_digit('B') == 11u8);
-    assert (char::to_digit('z') == 35u8);
-    assert (char::to_digit('Z') == 35u8);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_to_digit_fail_1() {
-    char::to_digit(' ');
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_to_digit_fail_2() {
-    char::to_digit('$');
-}
-
-#[test]
-fn test_to_lower() {
-    assert (char::to_lower('H') == 'h');
-    assert (char::to_lower('e') == 'e');
-    //assert (char::to_lower('Ö') == 'ö');
-    assert (char::to_lower('ß') == 'ß');
-}
-
-#[test]
-fn test_to_upper() {
-    assert (char::to_upper('l') == 'L');
-    assert (char::to_upper('Q') == 'Q');
-    //assert (char::to_upper('ü') == 'Ü');
-    assert (char::to_upper('ß') == 'ß');
-}

src/test/stdtest/comm.rs

@@ -1,46 +0,0 @@
-import core::*;
-
-use std;
-import comm;
-
-#[test]
-fn create_port_and_chan() { let p = comm::port::<int>(); comm::chan(p); }
-
-#[test]
-fn send_int() {
-    let p = comm::port::<int>();
-    let c = comm::chan(p);
-    comm::send(c, 22);
-}
-
-#[test]
-fn send_recv_fn() {
-    let p = comm::port::<int>();
-    let c = comm::chan::<int>(p);
-    comm::send(c, 42);
-    assert (comm::recv(p) == 42);
-}
-
-#[test]
-fn send_recv_fn_infer() {
-    let p = comm::port();
-    let c = comm::chan(p);
-    comm::send(c, 42);
-    assert (comm::recv(p) == 42);
-}
-
-#[test]
-fn chan_chan_infer() {
-    let p = comm::port(), p2 = comm::port::<int>();
-    let c = comm::chan(p);
-    comm::send(c, comm::chan(p2));
-    comm::recv(p);
-}
-
-#[test]
-fn chan_chan() {
-    let p = comm::port::<comm::chan<int>>(), p2 = comm::port::<int>();
-    let c = comm::chan(p);
-    comm::send(c, comm::chan(p2));
-    comm::recv(p);
-}

src/test/stdtest/either.rs

@@ -1,99 +0,0 @@
-import core::*;
-
-use std;
-import vec;
-import core::either::*;
-import vec::len;
-
-#[test]
-fn test_either_left() {
-    let val = left(10);
-    fn f_left(&&x: int) -> bool { x == 10 }
-    fn f_right(&&_x: uint) -> bool { false }
-    assert (either(f_left, f_right, val));
-}
-
-#[test]
-fn test_either_right() {
-    let val = right(10u);
-    fn f_left(&&_x: int) -> bool { false }
-    fn f_right(&&x: uint) -> bool { x == 10u }
-    assert (either(f_left, f_right, val));
-}
-
-#[test]
-fn test_lefts() {
-    let input = [left(10), right(11), left(12), right(13), left(14)];
-    let result = lefts(input);
-    assert (result == [10, 12, 14]);
-}
-
-#[test]
-fn test_lefts_none() {
-    let input: [t<int, int>] = [right(10), right(10)];
-    let result = lefts(input);
-    assert (len(result) == 0u);
-}
-
-#[test]
-fn test_lefts_empty() {
-    let input: [t<int, int>] = [];
-    let result = lefts(input);
-    assert (len(result) == 0u);
-}
-
-#[test]
-fn test_rights() {
-    let input = [left(10), right(11), left(12), right(13), left(14)];
-    let result = rights(input);
-    assert (result == [11, 13]);
-}
-
-#[test]
-fn test_rights_none() {
-    let input: [t<int, int>] = [left(10), left(10)];
-    let result = rights(input);
-    assert (len(result) == 0u);
-}
-
-#[test]
-fn test_rights_empty() {
-    let input: [t<int, int>] = [];
-    let result = rights(input);
-    assert (len(result) == 0u);
-}
-
-#[test]
-fn test_partition() {
-    let input = [left(10), right(11), left(12), right(13), left(14)];
-    let result = partition(input);
-    assert (result.lefts[0] == 10);
-    assert (result.lefts[1] == 12);
-    assert (result.lefts[2] == 14);
-    assert (result.rights[0] == 11);
-    assert (result.rights[1] == 13);
-}
-
-#[test]
-fn test_partition_no_lefts() {
-    let input: [t<int, int>] = [right(10), right(11)];
-    let result = partition(input);
-    assert (len(result.lefts) == 0u);
-    assert (len(result.rights) == 2u);
-}
-
-#[test]
-fn test_partition_no_rights() {
-    let input: [t<int, int>] = [left(10), left(11)];
-    let result = partition(input);
-    assert (len(result.lefts) == 2u);
-    assert (len(result.rights) == 0u);
-}
-
-#[test]
-fn test_partition_empty() {
-    let input: [t<int, int>] = [];
-    let result = partition(input);
-    assert (len(result.lefts) == 0u);
-    assert (len(result.rights) == 0u);
-}

src/test/stdtest/float.rs

@@ -1,85 +0,0 @@
-import core::*;
-
-use std;
-import float;
-
-#[test]
-fn test_from_str() {
-   assert ( float::from_str("3") == 3. );
-   assert ( float::from_str("  3  ") == 3. );
-   assert ( float::from_str("3.14") == 3.14 );
-   assert ( float::from_str("+3.14") == 3.14 );
-   assert ( float::from_str("-3.14") == -3.14 );
-   assert ( float::from_str("2.5E10") == 25000000000. );
-   assert ( float::from_str("2.5e10") == 25000000000. );
-   assert ( float::from_str("25000000000.E-10") == 2.5 );
-   assert ( float::from_str("") == 0. );
-   assert ( float::from_str(".") == 0. );
-   assert ( float::from_str(".e1") == 0. );
-   assert ( float::from_str(".e-1") == 0. );
-   assert ( float::from_str("5.") == 5. );
-   assert ( float::from_str(".5") == 0.5 );
-   assert ( float::from_str("0.5") == 0.5 );
-   assert ( float::from_str("0.5 ") == 0.5 );
-   assert ( float::from_str(" 0.5 ") == 0.5 );
-   assert ( float::from_str(" -.5 ") == -0.5 );
-   assert ( float::from_str(" -.5 ") == -0.5 );
-   assert ( float::from_str(" -5 ") == -5. );
-
-   assert ( float::is_NaN(float::from_str("x")) );
-   assert ( float::from_str(" ") == 0. );
-   assert ( float::from_str("   ") == 0. );
-   assert ( float::from_str(" 0.5") == 0.5 );
-   assert ( float::from_str(" 0.5 ") == 0.5 );
-   assert ( float::from_str(" .1 ") == 0.1 );
-   assert ( float::is_NaN(float::from_str("e")) );
-   assert ( float::is_NaN(float::from_str("E")) );
-   assert ( float::is_NaN(float::from_str("E1")) );
-   assert ( float::is_NaN(float::from_str("1e1e1")) );
-   assert ( float::is_NaN(float::from_str("1e1.1")) );
-   assert ( float::is_NaN(float::from_str("1e1-1")) );
-}
-
-#[test]
-fn test_positive() {
-  assert(float::is_positive(float::infinity));
-  assert(float::is_positive(1.));
-  assert(float::is_positive(0.));
-  assert(!float::is_positive(-1.));
-  assert(!float::is_positive(float::neg_infinity));
-  assert(!float::is_positive(1./float::neg_infinity));
-  assert(!float::is_positive(float::NaN));
-}
-
-#[test]
-fn test_negative() {
-  assert(!float::is_negative(float::infinity));
-  assert(!float::is_negative(1.));
-  assert(!float::is_negative(0.));
-  assert(float::is_negative(-1.));
-  assert(float::is_negative(float::neg_infinity));
-  assert(float::is_negative(1./float::neg_infinity));
-  assert(!float::is_negative(float::NaN));
-}
-
-#[test]
-fn test_nonpositive() {
-  assert(!float::is_nonpositive(float::infinity));
-  assert(!float::is_nonpositive(1.));
-  assert(!float::is_nonpositive(0.));
-  assert(float::is_nonpositive(-1.));
-  assert(float::is_nonpositive(float::neg_infinity));
-  assert(float::is_nonpositive(1./float::neg_infinity));
-  assert(!float::is_nonpositive(float::NaN));
-}
-
-#[test]
-fn test_nonnegative() {
-  assert(float::is_nonnegative(float::infinity));
-  assert(float::is_nonnegative(1.));
-  assert(float::is_nonnegative(0.));
-  assert(!float::is_nonnegative(-1.));
-  assert(!float::is_nonnegative(float::neg_infinity));
-  assert(!float::is_nonnegative(1./float::neg_infinity));
-  assert(!float::is_nonnegative(float::NaN));
-}

src/test/stdtest/int.rs

@@ -1,99 +0,0 @@
-import core::*;
-
-use std;
-import str;
-import int;
-import str::eq;
-import str::bytes;
-
-#[test]
-fn test_from_str() {
-    assert(int::from_str("0") == 0);
-    assert(int::from_str("3") == 3);
-    assert(int::from_str("10") == 10);
-    assert(int::from_str("123456789") == 123456789);
-    assert(int::from_str("00100") == 100);
-
-    assert(int::from_str("-1") == -1);
-    assert(int::from_str("-3") == -3);
-    assert(int::from_str("-10") == -10);
-    assert(int::from_str("-123456789") == -123456789);
-    assert(int::from_str("-00100") == -100);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_from_str_fail_1() {
-    int::from_str(" ");
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_from_str_fail_2() {
-    int::from_str("x");
-}
-
-#[test]
-fn test_parse_buf() {
-    assert (int::parse_buf(bytes("123"), 10u) == 123);
-    assert (int::parse_buf(bytes("1001"), 2u) == 9);
-    assert (int::parse_buf(bytes("123"), 8u) == 83);
-    assert (int::parse_buf(bytes("123"), 16u) == 291);
-    assert (int::parse_buf(bytes("ffff"), 16u) == 65535);
-    assert (int::parse_buf(bytes("FFFF"), 16u) == 65535);
-    assert (int::parse_buf(bytes("z"), 36u) == 35);
-    assert (int::parse_buf(bytes("Z"), 36u) == 35);
-
-    assert (int::parse_buf(bytes("-123"), 10u) == -123);
-    assert (int::parse_buf(bytes("-1001"), 2u) == -9);
-    assert (int::parse_buf(bytes("-123"), 8u) == -83);
-    assert (int::parse_buf(bytes("-123"), 16u) == -291);
-    assert (int::parse_buf(bytes("-ffff"), 16u) == -65535);
-    assert (int::parse_buf(bytes("-FFFF"), 16u) == -65535);
-    assert (int::parse_buf(bytes("-z"), 36u) == -35);
-    assert (int::parse_buf(bytes("-Z"), 36u) == -35);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_parse_buf_fail_1() {
-    int::parse_buf(bytes("Z"), 35u);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_parse_buf_fail_2() {
-    int::parse_buf(bytes("-9"), 2u);
-}
-
-#[test]
-fn test_to_str() {
-    assert (eq(int::to_str(0, 10u), "0"));
-    assert (eq(int::to_str(1, 10u), "1"));
-    assert (eq(int::to_str(-1, 10u), "-1"));
-    assert (eq(int::to_str(255, 16u), "ff"));
-    assert (eq(int::to_str(100, 10u), "100"));
-}
-
-#[test]
-fn test_pow() {
-    assert (int::pow(0, 0u) == 1);
-    assert (int::pow(0, 1u) == 0);
-    assert (int::pow(0, 2u) == 0);
-    assert (int::pow(-1, 0u) == 1);
-    assert (int::pow(1, 0u) == 1);
-    assert (int::pow(-3, 2u) == 9);
-    assert (int::pow(-3, 3u) == -27);
-    assert (int::pow(4, 9u) == 262144);
-}
-
-#[test]
-fn test_overflows() {
-   assert (int::max_value > 0);
-   assert (int::min_value <= 0);
-   assert (int::min_value + int::max_value + 1 == 0);
-}

src/test/stdtest/math.rs

@@ -1,304 +0,0 @@
-import core::*;
-
-use std;
-
-import math::{min, max};
-import float::*;
-import float;
-import c_int = ctypes::c_int;
-
-#[test]
-fn test_max_min() {
-    assert max(0, 1) == 1;
-    assert min(0, 1) == 0;
-    assert max(0, -1) == 0;
-    assert min(0, -1) == -1;
-    assert max(0.0, 1.0) == 1.0;
-    assert min(0.0, 1.0) == 0.0;
-}
-
-// FIXME use macros to execute the tests below for all float types
-
-/*
-#[test]
-fn test_trig() {
-    assert sin(0.0) == 0.0;
-    assert sin(-0.0) == 0.0;
-
-    assert float::isNaN(sin(float::infinity));
-    assert float::isNaN(sin(float::neg_infinity));
-
-    assert cos(0.0) == 1.0;
-    assert cos(-0.0) == 1.0;
-    assert float::isNaN(cos(float::infinity));
-    assert float::isNaN(cos(float::neg_infinity));
-
-    assert tan(0.0) == 0.0;
-    assert tan(-0.0) == 0.0;;
-    assert float::isNaN(tan(float::infinity));
-    assert float::isNaN(tan(float::neg_infinity));
-}
-
-#[test]
-fn test_inv_trig() {
-    assert asin(0.0) == 0.0;
-    assert asin(-0.0) == -0.0;
-    assert float::isNaN(asin(1.1));
-    assert float::isNaN(asin(-1.1));
-
-    assert acos(1.0) == 0.0;
-    assert float::isNaN(acos(1.1));
-    assert float::isNaN(acos(-1.1));
-
-    assert atan(0.0) == 0.0;
-    assert atan(-0.0) == 0.0;
-    assert atan(float::infinity) == consts::frac_pi_2;
-    assert atan(float::neg_infinity) == - consts::frac_pi_2;
-
-    assert atan2(0.0, -0.0) == consts::pi;
-    assert atan2(-0.0, -0.0) == -consts::pi;
-
-    assert atan2(0.0, 0.0) == 0.0;
-    assert atan2(-0.0, 0.0) == -0.0;
-
-    assert atan2(0.0, -1.0) == consts::pi;
-    assert atan2(-0.0, -1.0) == -consts::pi;
-
-    assert atan2(0.0, 1.0) == 0.0;
-    assert atan2(-0.0, 1.0) == -0.0;
-
-    assert atan2(1.0, 0.0) == consts::frac_pi_2;
-    assert atan2(1.0, -0.0) == consts::frac_pi_2;
-}
-
-// FIXME (1222): The commented-out tests give different results on windows
-#[test]
-fn test_pow() {
-    assert pow(2.0, 4.0) == 16.0;
-
-    assert pow(0.0, -3.0) == float::infinity;
-    assert pow(-0.0, -3.0) == float::neg_infinity;
-
-    assert pow(0.0, -4.0) == float::infinity;
-    assert pow(-0.0, -4.0) == float::infinity;
-
-    assert pow(0.0, 3.0) == 0.0;
-    assert pow(-0.0, 3.0) == -0.0;
-    assert pow(0.0, 4.0) == 0.0;
-    assert pow(-0.0, 4.0) == 0.0;
-
-    assert pow(-1.0, float::infinity) == 1.0;
-    //assert pow(-1.0, float::neg_infinity) == 1.0;
-
-    assert pow(1.0, 4.0) == 1.0;
-    assert pow(1.0, 0.0) == 1.0;
-    assert pow(1.0, -0.0) == 1.0;
-    //assert pow(1.0, float::NaN) == 1.0;
-    assert pow(1.0, float::infinity) == 1.0;
-    //assert pow(1.0, float::neg_infinity) == 1.0;
-    assert pow(1.0, -3.0) == 1.0;
-    assert pow(1.0, -4.0) == 1.0;
-
-    assert pow(4.0, 0.0) == 1.0;
-    assert pow(0.0, 0.0) == 1.0;
-    assert pow(-0.0, 0.0) == 1.0;
-    //assert pow(float::NaN, 0.0) == 1.0;
-    assert pow(float::infinity, 0.0) == 1.0;
-    assert pow(float::neg_infinity, 0.0) == 1.0;
-    assert pow(-3.0, 0.0) == 1.0;
-    assert pow(-4.0, 0.0) == 1.0;
-
-    assert pow(4.0, -0.0) == 1.0;
-    assert pow(0.0, -0.0) == 1.0;
-    assert pow(-0.0, -0.0) == 1.0;
-    //assert pow(float::NaN, -0.0) == 1.0;
-    assert pow(float::infinity, -0.0) == 1.0;
-    assert pow(float::neg_infinity, -0.0) == 1.0;
-    assert pow(-3.0, -0.0) == 1.0;
-    assert pow(-4.0, -0.0) == 1.0;
-
-    assert float::isNaN(pow(-1.0, -1.5));
-    assert float::isNaN(pow(-1.0, 1.5));
-
-    assert float::isNaN(pow(-1.2, -1.5));
-    assert float::isNaN(pow(-1.2, 1.5));
-
-    assert pow(0.5, float::neg_infinity) == float::infinity;
-    assert pow(-0.5, float::neg_infinity) == float::infinity;
-
-    assert pow(1.5, float::neg_infinity) == 0.0;
-    assert pow(-1.5, float::neg_infinity) == 0.0;
-
-    assert pow(0.5, float::infinity) == 0.0;
-    assert pow(-0.5, float::infinity) == 0.0;
-
-    assert pow(-1.5, float::infinity) == float::infinity;
-    assert pow(1.5, float::infinity) == float::infinity;
-
-    assert pow(float::neg_infinity, -3.0) == -0.0;
-    assert pow(float::neg_infinity, -4.0) == 0.0;
-
-    assert pow(float::neg_infinity, 3.0) == float::neg_infinity;
-    assert pow(float::neg_infinity, 4.0) == float::infinity;
-
-    assert pow(float::infinity, -16.0) == 0.0;
-    assert pow(float::infinity, 16.0) == float::infinity;
-}
-
-// FIXME (1222): The commented-out tests give different results on windows
-#[test]
-fn test_exp_and_mod() {
-    assert exp(0.0) == 1.0;
-    assert exp(-0.0) == 1.0;
-    assert exp(float::neg_infinity) == 0.0;
-    assert exp(float::infinity) == float::infinity;
-
-    let d1: c_int = 1 as c_int;
-    assert frexp(0.0, d1) == 0.0;
-    assert frexp(-0.0, d1) == 0.0;
-    //assert frexp(float::infinity, d1) == float::infinity;
-    //assert frexp(float::neg_infinity, d1) == float::neg_infinity;
-    assert float::isNaN(frexp(float::NaN, d1));
-
-    let d2: float = 1.0;
-    assert modf(float::infinity, d2) == 0.0;
-    assert d2 == float::infinity;
-    assert modf(float::neg_infinity, d2) == -0.0;
-    assert d2 == float::neg_infinity;
-    assert float::isNaN(modf(float::NaN, d2));
-    assert float::isNaN(d2);
-}
-
-#[test]
-fn test_round_and_abs() {
-    assert abs(0.0) == 0.0;
-    assert abs(-0.0) == 0.0;
-    assert abs(float::infinity) == float::infinity;
-    assert abs(float::neg_infinity) == float::infinity;
-
-    assert abs(-2.5) == 2.5;
-    assert abs(2.5) == 2.5;
-
-    assert ceil(0.0) == 0.0;
-    assert ceil(-0.0) == -0.0;
-    assert ceil(float::infinity) == float::infinity;
-    assert ceil(float::neg_infinity) == float::neg_infinity;
-
-    assert ceil(1.9) == 2.0;
-    assert ceil(-1.9) == -1.0;
-
-    assert floor(0.0) == 0.0;
-    assert floor(-0.0) == -0.0;
-    assert floor(float::infinity) == float::infinity;
-    assert floor(float::neg_infinity) == float::neg_infinity;
-
-    assert floor(1.9) == 1.0;
-    assert floor(-1.9) == -2.0;
-
-    assert trunc(0.0) == 0.0;
-    assert trunc(-0.0) == -0.0;
-    assert trunc(float::infinity) == float::infinity;
-    assert trunc(float::neg_infinity) == float::neg_infinity;
-
-    assert trunc(1.5) == 1.0;
-    assert trunc(1.2) == 1.0;
-    assert trunc(1.0) == 1.0;
-    assert trunc(1.9) == 1.0;
-    assert trunc(-1.5) == -1.0;
-    assert trunc(-1.2) == -1.0;
-    assert trunc(-1.0) == -1.0;
-    assert trunc(-1.9) == -1.0;
-
-    assert round(0.0) == 0.0;
-    assert round(-0.0) == -0.0;
-    assert round(float::infinity) == float::infinity;
-    assert round(float::neg_infinity) == float::neg_infinity;
-
-    assert rint(0.0) == 0.0;
-    assert rint(-0.0) == -0.0;
-    assert rint(float::infinity) == float::infinity;
-    assert rint(float::neg_infinity) == float::neg_infinity;
-}
-
-#[test]
-fn test_hyp_trig() {
-    assert sinh(0.0) == 0.0;
-    assert sinh(-0.0) == 0.0;
-    assert sinh(float::infinity) == float::infinity;
-    assert sinh(float::neg_infinity) == float::neg_infinity;
-
-    assert cosh(0.0) == 1.0;
-    assert cosh(-0.0) == 1.0;
-    assert cosh(float::infinity) == float::infinity;
-    assert cosh(float::neg_infinity) == float::infinity;
-
-    assert tanh(0.0) == 0.0;
-    assert tanh(-0.0) == 0.0;
-    assert tanh(float::infinity) == 1.0;
-    assert tanh(float::neg_infinity) == -1.0;
-}
-
-#[test]
-fn test_sqrt() {
-    assert sqrt(9.0) == 3.0;
-    assert sqrt(4.0) == 2.0;
-    assert sqrt(1.0) == 1.0;
-    assert sqrt(0.0) == 0.0;
-}
-
-
-#[test]
-fn test_angle() {
-    fn angle(vec: (float, float)) -> float {
-        alt vec {
-          (0f, y) if y < 0f { 1.5 * consts::pi }
-          (0f, y) { 0.5 * consts::pi }
-          (x, y) { float::atan(y / x) }
-        }
-    }
-    assert angle((1f, 0f)) == 0f;
-    assert angle((1f, 1f)) == 0.25 * consts::pi;
-    assert angle((0f, 1f)) == 0.5 * consts::pi;
-}
-
-
-#[test]
-fn test_log_functions() {
-    assert ln(1.0) == 0.0;
-    assert log2(1.0) == 0.0;
-    assert log10(1.0) == 0.0;
-
-    // FIXME remove round-up due to valgrind weirdness
-    assert ceil(ln(consts::e)) == 1.0; /* ln(e) == 0.999.. under valgrind */
-    assert log2(2.0) == 1.0;
-    assert log10(10.0) == 1.0;
-
-    // FIXME remove round-up due to valgrind weirdness
-    assert ceil(ln(consts::e*consts::e*consts::e*consts::e)) == 4.0;
-    assert log2(256.0) == 8.0;
-    assert log10(1000.0) == 3.0;
-
-    assert ln(0.0) == float::neg_infinity;
-    assert log2(0.0) == float::neg_infinity;
-    assert log10(0.0) == float::neg_infinity;
-
-    assert ln(-0.0) == float::neg_infinity;
-    assert log2(-0.0) == float::neg_infinity;
-    assert log10(-0.0) == float::neg_infinity;
-
-    assert float::isNaN(ln(-1.0));
-    assert float::isNaN(log2(-1.0));
-    assert float::isNaN(log10(-1.0));
-
-    assert ln(float::infinity) == float::infinity;
-    assert log2(float::infinity) == float::infinity;
-    assert log10(float::infinity) == float::infinity;
-
-    assert ln1p(0.0) == 0.0;
-    assert ln1p(-0.0) == 0.0;
-    assert ln1p(-1.0) == float::neg_infinity;
-    assert float::isNaN(ln1p(-2.0f));
-    assert ln1p(float::infinity) == float::infinity;
-}
-
-*/

src/test/stdtest/option.rs

@@ -1,6 +0,0 @@
-import core::*;
-
-use std;
-
-#[test]
-fn test() { let _x = option::some::<int>(10); }

src/test/stdtest/ptr.rs

@@ -1,24 +0,0 @@
-import core::*;
-
-use std;
-import ptr;
-import unsafe;
-
-type pair = {mutable fst: int, mutable snd: int};
-
-#[test]
-fn test() unsafe {
-    let p = {mutable fst: 10, mutable snd: 20};
-    let pptr: *mutable pair = ptr::mut_addr_of(p);
-    let iptr: *mutable int = unsafe::reinterpret_cast(pptr);
-    assert (*iptr == 10);;
-    *iptr = 30;
-    assert (*iptr == 30);
-    assert (p.fst == 30);;
-
-    *pptr = {mutable fst: 50, mutable snd: 60};
-    assert (*iptr == 50);
-    assert (p.fst == 50);
-    assert (p.snd == 60);
-}
-

src/test/stdtest/result.rs

@@ -1,19 +0,0 @@
-import core::*;
-
-import result;
-
-fn op1() -> result::t<int, str> { result::ok(666) }
-
-fn op2(&&i: int) -> result::t<uint, str> { result::ok(i as uint + 1u) }
-
-fn op3() -> result::t<int, str> { result::err("sadface") }
-
-#[test]
-fn chain_success() {
-    assert result::get(result::chain(op1(), op2)) == 667u;
-}
-
-#[test]
-fn chain_failure() {
-    assert result::get_err(result::chain(op3(), op2)) == "sadface";
-}

src/test/stdtest/stdtest.rc

@@ -1,51 +1,34 @@
 use std;
 
 mod bitv;
-mod bool;
-mod box;
 mod c_vec;
-mod char;
-mod comm;
 mod deque;
-mod either;
-mod float;
 mod four;
 mod fs;
 mod getopts;
-mod int;
 mod io;
 mod json;
 mod list;
 mod map;
-mod math;
 mod net;
-mod option;
 mod os;
 mod path;
-mod ptr;
 mod qsort3;
 mod qsort;
 mod rand;
-mod result;
 mod rope;
 mod run;
 mod sha1;
 mod sort;
-mod str;
-mod sys;
-mod task;
 mod tempfile;
 mod test;
 mod tri;
 mod treemap;
-mod uint;
 
 #[cfg(unicode)]
 mod unicode;
 
-mod unsafe;
 mod uv;
-mod vec;
 
 // Local Variables:
 // mode: rust

src/test/stdtest/str.rs

@@ -1,461 +0,0 @@
-import core::*;
-
-import str;
-import vec;
-
-#[test]
-fn test_eq() {
-    assert (str::eq("", ""));
-    assert (str::eq("foo", "foo"));
-    assert (!str::eq("foo", "bar"));
-}
-
-#[test]
-fn test_lteq() {
-    assert (str::lteq("", ""));
-    assert (str::lteq("", "foo"));
-    assert (str::lteq("foo", "foo"));
-    assert (!str::eq("foo", "bar"));
-}
-
-#[test]
-fn test_bytes_len() {
-    assert (str::byte_len("") == 0u);
-    assert (str::byte_len("hello world") == 11u);
-    assert (str::byte_len("\x63") == 1u);
-    assert (str::byte_len("\xa2") == 2u);
-    assert (str::byte_len("\u03c0") == 2u);
-    assert (str::byte_len("\u2620") == 3u);
-    assert (str::byte_len("\U0001d11e") == 4u);
-}
-
-#[test]
-fn test_index_and_rindex() {
-    assert (str::index("hello", 'e' as u8) == 1);
-    assert (str::index("hello", 'o' as u8) == 4);
-    assert (str::index("hello", 'z' as u8) == -1);
-    assert (str::rindex("hello", 'l' as u8) == 3);
-    assert (str::rindex("hello", 'h' as u8) == 0);
-    assert (str::rindex("hello", 'z' as u8) == -1);
-}
-
-#[test]
-fn test_split() {
-    fn t(s: str, c: char, u: [str]) {
-        log(debug, "split: " + s);
-        let v = str::split(s, c as u8);
-        #debug("split to: ");
-        log(debug, v);
-        assert (vec::all2(v, u, { |a,b| a == b }));
-    }
-    t("abc.hello.there", '.', ["abc", "hello", "there"]);
-    t(".hello.there", '.', ["", "hello", "there"]);
-    t("...hello.there.", '.', ["", "", "", "hello", "there", ""]);
-}
-
-#[test]
-fn test_splitn() {
-    fn t(s: str, c: char, n: uint, u: [str]) {
-        log(debug, "splitn: " + s);
-        let v = str::splitn(s, c as u8, n);
-        #debug("split to: ");
-        log(debug, v);
-        #debug("comparing vs. ");
-        log(debug, u);
-        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"]);
-    t("abc.hello.there", '.', 2u, ["abc", "hello", "there"]);
-    t("abc.hello.there", '.', 3u, ["abc", "hello", "there"]);
-    t(".hello.there", '.', 0u, [".hello.there"]);
-    t(".hello.there", '.', 1u, ["", "hello.there"]);
-    t("...hello.there.", '.', 3u, ["", "", "", "hello.there."]);
-    t("...hello.there.", '.', 5u, ["", "", "", "hello", "there", ""]);
-}
-
-#[test]
-fn test_split_str() {
-    fn t(s: str, sep: str, i: int, k: str) {
-        let v = str::split_str(s, sep);
-        assert str::eq(v[i], k);
-    }
-
-    //FIXME: should behave like split and split_char:
-    //assert ["", "XXX", "YYY", ""] == str::split_str(".XXX.YYY.", ".");
-
-    t("abc::hello::there", "::", 0, "abc");
-    t("abc::hello::there", "::", 1, "hello");
-    t("abc::hello::there", "::", 2, "there");
-    t("::hello::there", "::", 0, "hello");
-    t("hello::there::", "::", 2, "");
-    t("::hello::there::", "::", 2, "");
-    t("ประเทศไทย中华Việt Nam", "中华", 0, "ประเทศไทย");
-    t("ประเทศไทย中华Việt Nam", "中华", 1, "Việt Nam");
-}
-
-#[test]
-fn test_split_func () {
-    let data = "ประเทศไทย中华Việt Nam";
-    assert ["ประเทศไทย中", "Việt Nam"]
-        == str::split_func (data, {|cc| cc == '华'});
-
-    assert ["", "", "XXX", "YYY", ""]
-         == str::split_func("zzXXXzYYYz", char::is_lowercase);
-
-    assert ["zz", "", "", "z", "", "", "z"]
-         == str::split_func("zzXXXzYYYz", char::is_uppercase);
-
-    assert ["",""] == str::split_func("z", {|cc| cc == 'z'});
-    assert [""] == str::split_func("", {|cc| cc == 'z'});
-    assert ["ok"] == str::split_func("ok", {|cc| cc == 'z'});
-}
-
-#[test]
-fn test_split_char () {
-    let data = "ประเทศไทย中华Việt Nam";
-    assert ["ประเทศไทย中", "Việt Nam"]
-        == str::split_char(data, '华');
-
-    assert ["", "", "XXX", "YYY", ""]
-         == str::split_char("zzXXXzYYYz", 'z');
-    assert ["",""] == str::split_char("z", 'z');
-    assert [""] == str::split_char("", 'z');
-    assert ["ok"] == str::split_char("ok", 'z');
-}
-
-#[test]
-fn test_lines () {
-    let lf = "\nMary had a little lamb\nLittle lamb\n";
-    let crlf = "\r\nMary had a little lamb\r\nLittle lamb\r\n";
-
-    assert ["", "Mary had a little lamb", "Little lamb", ""]
-      == str::lines(lf);
-
-    assert ["", "Mary had a little lamb", "Little lamb", ""]
-      == str::lines_any(lf);
-
-    assert ["\r", "Mary had a little lamb\r", "Little lamb\r", ""]
-      == str::lines(crlf);
-
-    assert ["", "Mary had a little lamb", "Little lamb", ""]
-      == str::lines_any(crlf);
-
-    assert [""] == str::lines    ("");
-    assert [""] == str::lines_any("");
-    assert ["",""] == str::lines    ("\n");
-    assert ["",""] == str::lines_any("\n");
-    assert ["banana"] == str::lines    ("banana");
-    assert ["banana"] == str::lines_any("banana");
-}
-
-#[test]
-fn test_words () {
-    let data = "\nMary had a little lamb\nLittle lamb\n";
-    assert ["Mary","had","a","little","lamb","Little","lamb"]
-        == str::words(data);
-
-    assert ["ok"] == str::words("ok");
-    assert [] == str::words("");
-}
-
-#[test]
-fn test_find() {
-    fn t(haystack: str, needle: str, i: int) {
-        let j: int = str::find(haystack, needle);
-        log(debug, "searched for " + needle);
-        log(debug, j);
-        assert (i == j);
-    }
-    t("this is a simple", "is a", 5);
-    t("this is a simple", "is z", -1);
-    t("this is a simple", "", 0);
-    t("this is a simple", "simple", 10);
-    t("this", "simple", -1);
-}
-
-#[test]
-fn test_substr() {
-    fn t(a: str, b: str, start: int) {
-        assert (str::eq(str::substr(a, start as uint, str::byte_len(b)), b));
-    }
-    t("hello", "llo", 2);
-    t("hello", "el", 1);
-    t("substr should not be a challenge", "not", 14);
-}
-
-#[test]
-fn test_concat() {
-    fn t(v: [str], s: str) { assert (str::eq(str::concat(v), s)); }
-    t(["you", "know", "I'm", "no", "good"], "youknowI'mnogood");
-    let v: [str] = [];
-    t(v, "");
-    t(["hi"], "hi");
-}
-
-#[test]
-fn test_connect() {
-    fn t(v: [str], sep: str, s: str) {
-        assert (str::eq(str::connect(v, sep), s));
-    }
-    t(["you", "know", "I'm", "no", "good"], " ", "you know I'm no good");
-    let v: [str] = [];
-    t(v, " ", "");
-    t(["hi"], " ", "hi");
-}
-
-#[test]
-fn test_to_upper() {
-    // to_upper doesn't understand unicode yet,
-    // but we need to at least preserve it
-
-    let unicode = "\u65e5\u672c";
-    let input = "abcDEF" + unicode + "xyz:.;";
-    let expected = "ABCDEF" + unicode + "XYZ:.;";
-    let actual = str::to_upper(input);
-    assert (str::eq(expected, actual));
-}
-
-#[test]
-fn test_slice() {
-    assert (str::eq("ab", str::slice("abc", 0u, 2u)));
-    assert (str::eq("bc", str::slice("abc", 1u, 3u)));
-    assert (str::eq("", str::slice("abc", 1u, 1u)));
-    fn a_million_letter_a() -> str {
-        let i = 0;
-        let rs = "";
-        while i < 100000 { rs += "aaaaaaaaaa"; i += 1; }
-        ret rs;
-    }
-    fn half_a_million_letter_a() -> str {
-        let i = 0;
-        let rs = "";
-        while i < 100000 { rs += "aaaaa"; i += 1; }
-        ret rs;
-    }
-    assert (str::eq(half_a_million_letter_a(),
-                    str::slice(a_million_letter_a(), 0u, 500000u)));
-}
-
-#[test]
-fn test_starts_with() {
-    assert (str::starts_with("", ""));
-    assert (str::starts_with("abc", ""));
-    assert (str::starts_with("abc", "a"));
-    assert (!str::starts_with("a", "abc"));
-    assert (!str::starts_with("", "abc"));
-}
-
-#[test]
-fn test_ends_with() {
-    assert (str::ends_with("", ""));
-    assert (str::ends_with("abc", ""));
-    assert (str::ends_with("abc", "c"));
-    assert (!str::ends_with("a", "abc"));
-    assert (!str::ends_with("", "abc"));
-}
-
-#[test]
-fn test_is_empty() {
-    assert (str::is_empty(""));
-    assert (!str::is_empty("a"));
-}
-
-#[test]
-fn test_is_not_empty() {
-    assert (str::is_not_empty("a"));
-    assert (!str::is_not_empty(""));
-}
-
-#[test]
-fn test_replace() {
-    let a = "a";
-    check (str::is_not_empty(a));
-    assert (str::replace("", a, "b") == "");
-    assert (str::replace("a", a, "b") == "b");
-    assert (str::replace("ab", a, "b") == "bb");
-    let test = "test";
-    check (str::is_not_empty(test));
-    assert (str::replace(" test test ", test, "toast") == " toast toast ");
-    assert (str::replace(" test test ", test, "") == "   ");
-}
-
-#[test]
-fn test_char_slice() {
-    assert (str::eq("ab", str::char_slice("abc", 0u, 2u)));
-    assert (str::eq("bc", str::char_slice("abc", 1u, 3u)));
-    assert (str::eq("", str::char_slice("abc", 1u, 1u)));
-    assert (str::eq("\u65e5", str::char_slice("\u65e5\u672c", 0u, 1u)));
-
-    let data = "ประเทศไทย中华";
-    assert (str::eq("ป", str::char_slice(data, 0u, 1u)));
-    assert (str::eq("ร", str::char_slice(data, 1u, 2u)));
-    assert (str::eq("华", str::char_slice(data, 10u, 11u)));
-    assert (str::eq("", str::char_slice(data, 1u, 1u)));
-
-    fn a_million_letter_X() -> str {
-        let i = 0;
-        let rs = "";
-        while i < 100000 { rs += "华华华华华华华华华华"; i += 1; }
-        ret rs;
-    }
-    fn half_a_million_letter_X() -> str {
-        let i = 0;
-        let rs = "";
-        while i < 100000 { rs += "华华华华华"; i += 1; }
-        ret rs;
-    }
-    assert (str::eq(half_a_million_letter_X(),
-                    str::char_slice(a_million_letter_X(), 0u, 500000u)));
-}
-
-#[test]
-fn trim_left() {
-    assert (str::trim_left("") == "");
-    assert (str::trim_left("a") == "a");
-    assert (str::trim_left("    ") == "");
-    assert (str::trim_left("     blah") == "blah");
-    assert (str::trim_left("   \u3000  wut") == "wut");
-    assert (str::trim_left("hey ") == "hey ");
-}
-
-#[test]
-fn trim_right() {
-    assert (str::trim_right("") == "");
-    assert (str::trim_right("a") == "a");
-    assert (str::trim_right("    ") == "");
-    assert (str::trim_right("blah     ") == "blah");
-    assert (str::trim_right("wut   \u3000  ") == "wut");
-    assert (str::trim_right(" hey") == " hey");
-}
-
-#[test]
-fn trim() {
-    assert (str::trim("") == "");
-    assert (str::trim("a") == "a");
-    assert (str::trim("    ") == "");
-    assert (str::trim("    blah     ") == "blah");
-    assert (str::trim("\nwut   \u3000  ") == "wut");
-    assert (str::trim(" hey dude ") == "hey dude");
-}
-
-#[test]
-fn is_whitespace() {
-    assert (str::is_whitespace(""));
-    assert (str::is_whitespace(" "));
-    assert (str::is_whitespace("\u2009")); // Thin space
-    assert (str::is_whitespace("  \n\t   "));
-    assert (!str::is_whitespace("   _   "));
-}
-
-#[test]
-fn is_ascii() {
-    assert (str::is_ascii(""));
-    assert (str::is_ascii("a"));
-    assert (!str::is_ascii("\u2009"));
-}
-
-#[test]
-fn shift_byte() {
-    let s = "ABC";
-    let b = str::shift_byte(s);
-    assert (s == "BC");
-    assert (b == 65u8);
-}
-
-#[test]
-fn pop_byte() {
-    let s = "ABC";
-    let b = str::pop_byte(s);
-    assert (s == "AB");
-    assert (b == 67u8);
-}
-
-#[test]
-fn unsafe_from_bytes() {
-    let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8];
-    let b = str::unsafe_from_bytes(a);
-    assert (b == "AAAAAAA");
-}
-
-#[test]
-fn from_cstr() unsafe {
-    let a = [65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 65u8, 0u8];
-    let b = vec::to_ptr(a);
-    let c = str::from_cstr(b);
-    assert (c == "AAAAAAA");
-}
-
-#[test]
-fn as_buf() unsafe {
-    let a = "Abcdefg";
-    let b = str::as_buf(a, {|buf| assert (*buf == 65u8); 100 });
-    assert (b == 100);
-}
-
-#[test]
-fn as_buf_small() unsafe {
-    let a = "A";
-    let b = str::as_buf(a, {|buf| assert (*buf == 65u8); 100 });
-    assert (b == 100);
-}
-
-#[test]
-fn as_buf2() unsafe {
-    let s = "hello";
-    let sb = str::as_buf(s, {|b| b });
-    let s_cstr = str::from_cstr(sb);
-    assert (str::eq(s_cstr, s));
-}
-
-#[test]
-fn vec_str_conversions() {
-    let s1: str = "All mimsy were the borogoves";
-
-    let v: [u8] = str::bytes(s1);
-    let s2: str = str::unsafe_from_bytes(v);
-    let i: uint = 0u;
-    let n1: uint = str::byte_len(s1);
-    let n2: uint = vec::len::<u8>(v);
-    assert (n1 == n2);
-    while i < n1 {
-        let a: u8 = s1[i];
-        let b: u8 = s2[i];
-        log(debug, a);
-        log(debug, b);
-        assert (a == b);
-        i += 1u;
-    }
-}
-
-#[test]
-fn contains() {
-    assert str::contains("abcde", "bcd");
-    assert str::contains("abcde", "abcd");
-    assert str::contains("abcde", "bcde");
-    assert str::contains("abcde", "");
-    assert str::contains("", "");
-    assert !str::contains("abcde", "def");
-    assert !str::contains("", "a");
-}
-
-#[test]
-fn iter_chars() {
-    let i = 0;
-    str::iter_chars("x\u03c0y") {|ch|
-        alt i {
-          0 { assert ch == 'x'; }
-          1 { assert ch == '\u03c0'; }
-          2 { assert ch == 'y'; }
-        }
-        i += 1;
-    }
-}
-
-#[test]
-fn escape() {
-    assert(str::escape("abcdef") == "abcdef");
-    assert(str::escape("abc\\def") == "abc\\\\def");
-    assert(str::escape("abc\ndef") == "abc\\ndef");
-    assert(str::escape("abc\"def") == "abc\\\"def");
-}

src/test/stdtest/sys.rs

@@ -1,53 +0,0 @@
-import core::*;
-
-import sys;
-
-#[test]
-fn last_os_error() {
-    log(debug, sys::last_os_error());
-}
-
-#[test]
-fn size_of_basic() {
-    assert sys::size_of::<u8>() == 1u;
-    assert sys::size_of::<u16>() == 2u;
-    assert sys::size_of::<u32>() == 4u;
-    assert sys::size_of::<u64>() == 8u;
-}
-
-#[test]
-#[cfg(target_arch = "x86")]
-#[cfg(target_arch = "arm")]
-fn size_of_32() {
-    assert sys::size_of::<uint>() == 4u;
-    assert sys::size_of::<*uint>() == 4u;
-}
-
-#[test]
-#[cfg(target_arch = "x86_64")]
-fn size_of_64() {
-    assert sys::size_of::<uint>() == 8u;
-    assert sys::size_of::<*uint>() == 8u;
-}
-
-#[test]
-fn align_of_basic() {
-    assert sys::align_of::<u8>() == 1u;
-    assert sys::align_of::<u16>() == 2u;
-    assert sys::align_of::<u32>() == 4u;
-}
-
-#[test]
-#[cfg(target_arch = "x86")]
-#[cfg(target_arch = "arm")]
-fn align_of_32() {
-    assert sys::align_of::<uint>() == 4u;
-    assert sys::align_of::<*uint>() == 4u;
-}
-
-#[test]
-#[cfg(target_arch = "x86_64")]
-fn align_of_64() {
-    assert sys::align_of::<uint>() == 8u;
-    assert sys::align_of::<*uint>() == 8u;
-}

src/test/stdtest/task.rs

@@ -1,80 +0,0 @@
-import core::*;
-
-use std;
-import task;
-import comm;
-
-#[test]
-fn test_sleep() { task::sleep(1000000u); }
-
-// FIXME: Leaks on windows
-#[test]
-#[ignore(cfg(target_os = "win32"))]
-fn test_unsupervise() {
-    fn f() { task::unsupervise(); fail; }
-    task::spawn {|| f();};
-}
-
-#[test]
-fn test_lib_spawn() {
-    fn foo() { #error("Hello, World!"); }
-    task::spawn {|| foo();};
-}
-
-#[test]
-fn test_lib_spawn2() {
-    fn foo(x: int) { assert (x == 42); }
-    task::spawn {|| foo(42);};
-}
-
-#[test]
-fn test_join_chan() {
-    fn winner() { }
-
-    let t = task::spawn_joinable {|| winner();};
-    alt task::join(t) {
-      task::tr_success. {/* yay! */ }
-      _ { fail "invalid task status received" }
-    }
-}
-
-// FIXME: Leaks on windows
-#[test]
-#[ignore(cfg(target_os = "win32"))]
-fn test_join_chan_fail() {
-    fn failer() { task::unsupervise(); fail }
-
-    let t = task::spawn_joinable {|| failer();};
-    alt task::join(t) {
-      task::tr_failure. {/* yay! */ }
-      _ { fail "invalid task status received" }
-    }
-}
-
-#[test]
-fn spawn_polymorphic() {
-    fn foo<T:send>(x: T) { log(error, x); }
-    task::spawn {|| foo(true);};
-    task::spawn {|| foo(42);};
-}
-
-#[test]
-fn try_success() {
-    alt task::try {||
-        "Success!"
-    } {
-        result::ok("Success!") { }
-        _ { fail; }
-    }
-}
-
-#[test]
-#[ignore(cfg(target_os = "win32"))]
-fn try_fail() {
-    alt task::try {||
-        fail
-    } {
-        result::err(()) { }
-        _ { fail; }
-    }
-}

src/test/stdtest/uint.rs

@@ -1,112 +0,0 @@
-import core::*;
-
-// -*- rust -*-
-use std;
-import str;
-import uint;
-import str::bytes;
-
-#[test]
-fn test_from_str() {
-    assert (uint::from_str("0") == 0u);
-    assert (uint::from_str("3") == 3u);
-    assert (uint::from_str("10") == 10u);
-    assert (uint::from_str("123456789") == 123456789u);
-    assert (uint::from_str("00100") == 100u);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_from_str_fail_1() {
-    uint::from_str(" ");
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_from_str_fail_2() {
-    uint::from_str("x");
-}
-
-#[test]
-fn test_parse_buf() {
-    assert (uint::parse_buf(bytes("123"), 10u) == 123u);
-    assert (uint::parse_buf(bytes("1001"), 2u) == 9u);
-    assert (uint::parse_buf(bytes("123"), 8u) == 83u);
-    assert (uint::parse_buf(bytes("123"), 16u) == 291u);
-    assert (uint::parse_buf(bytes("ffff"), 16u) == 65535u);
-    assert (uint::parse_buf(bytes("z"), 36u) == 35u);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_parse_buf_fail_1() {
-    uint::parse_buf(bytes("Z"), 10u);
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn test_parse_buf_fail_2() {
-    uint::parse_buf(bytes("_"), 2u);
-}
-
-#[test]
-fn test_next_power_of_two() {
-    assert (uint::next_power_of_two(0u) == 0u);
-    assert (uint::next_power_of_two(1u) == 1u);
-    assert (uint::next_power_of_two(2u) == 2u);
-    assert (uint::next_power_of_two(3u) == 4u);
-    assert (uint::next_power_of_two(4u) == 4u);
-    assert (uint::next_power_of_two(5u) == 8u);
-    assert (uint::next_power_of_two(6u) == 8u);
-    assert (uint::next_power_of_two(7u) == 8u);
-    assert (uint::next_power_of_two(8u) == 8u);
-    assert (uint::next_power_of_two(9u) == 16u);
-    assert (uint::next_power_of_two(10u) == 16u);
-    assert (uint::next_power_of_two(11u) == 16u);
-    assert (uint::next_power_of_two(12u) == 16u);
-    assert (uint::next_power_of_two(13u) == 16u);
-    assert (uint::next_power_of_two(14u) == 16u);
-    assert (uint::next_power_of_two(15u) == 16u);
-    assert (uint::next_power_of_two(16u) == 16u);
-    assert (uint::next_power_of_two(17u) == 32u);
-    assert (uint::next_power_of_two(18u) == 32u);
-    assert (uint::next_power_of_two(19u) == 32u);
-    assert (uint::next_power_of_two(20u) == 32u);
-    assert (uint::next_power_of_two(21u) == 32u);
-    assert (uint::next_power_of_two(22u) == 32u);
-    assert (uint::next_power_of_two(23u) == 32u);
-    assert (uint::next_power_of_two(24u) == 32u);
-    assert (uint::next_power_of_two(25u) == 32u);
-    assert (uint::next_power_of_two(26u) == 32u);
-    assert (uint::next_power_of_two(27u) == 32u);
-    assert (uint::next_power_of_two(28u) == 32u);
-    assert (uint::next_power_of_two(29u) == 32u);
-    assert (uint::next_power_of_two(30u) == 32u);
-    assert (uint::next_power_of_two(31u) == 32u);
-    assert (uint::next_power_of_two(32u) == 32u);
-    assert (uint::next_power_of_two(33u) == 64u);
-    assert (uint::next_power_of_two(34u) == 64u);
-    assert (uint::next_power_of_two(35u) == 64u);
-    assert (uint::next_power_of_two(36u) == 64u);
-    assert (uint::next_power_of_two(37u) == 64u);
-    assert (uint::next_power_of_two(38u) == 64u);
-    assert (uint::next_power_of_two(39u) == 64u);
-}
-
-#[test]
-fn test_overflows() {
-   assert (uint::max_value > 0u);
-   assert (uint::min_value <= 0u);
-   assert (uint::min_value + uint::max_value + 1u == 0u);
-}
-
-#[test]
-fn test_div() {
-    assert(uint::div_floor(3u, 4u) == 0u);
-    assert(uint::div_ceil(3u, 4u)  == 1u);
-    assert(uint::div_round(3u, 4u) == 1u);
-}

src/test/stdtest/unsafe.rs

@@ -1,15 +0,0 @@
-import core::*;
-
-import unsafe;
-
-#[test]
-fn reinterpret_cast() unsafe {
-    assert unsafe::reinterpret_cast(1) == 1u;
-}
-
-#[test]
-#[should_fail]
-#[ignore(cfg(target_os = "win32"))]
-fn reinterpret_cast_wrong_size() unsafe {
-    let _i: uint = unsafe::reinterpret_cast(0u8);
-}

src/test/stdtest/vec.rs

@@ -1,531 +0,0 @@
-import core::*;
-
-import vec;
-import vec::*;
-import option;
-import option::none;
-import option::some;
-import task;
-
-
-fn square(n: uint) -> uint { ret n * n; }
-
-fn square_ref(&&n: uint) -> uint { ret n * n; }
-
-pure fn is_three(&&n: uint) -> bool { ret n == 3u; }
-
-pure fn is_odd(&&n: uint) -> bool { ret n % 2u == 1u; }
-
-pure fn is_equal(&&x: uint, &&y:uint) -> bool { ret x == y; }
-
-fn square_if_odd(&&n: uint) -> option::t<uint> {
-    ret if n % 2u == 1u { some(n * n) } else { none };
-}
-
-fn add(&&x: uint, &&y: uint) -> uint { ret x + y; }
-
-#[test]
-fn test_unsafe_ptrs() unsafe {
-    // Test on-stack copy-from-buf.
-    let a = [1, 2, 3];
-    let ptr = vec::to_ptr(a);
-    let b = vec::unsafe::from_buf(ptr, 3u);
-    assert (vec::len(b) == 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 = vec::to_ptr(c);
-    let d = vec::unsafe::from_buf(ptr, 5u);
-    assert (vec::len(d) == 5u);
-    assert (d[0] == 1);
-    assert (d[1] == 2);
-    assert (d[2] == 3);
-    assert (d[3] == 4);
-    assert (d[4] == 5);
-}
-
-#[test]
-fn test_init_fn() {
-    // Test on-stack init_fn.
-    let v = vec::init_fn(square, 3u);
-    assert (vec::len(v) == 3u);
-    assert (v[0] == 0u);
-    assert (v[1] == 1u);
-    assert (v[2] == 4u);
-
-    // Test on-heap init_fn.
-    v = vec::init_fn(square, 5u);
-    assert (vec::len(v) == 5u);
-    assert (v[0] == 0u);
-    assert (v[1] == 1u);
-    assert (v[2] == 4u);
-    assert (v[3] == 9u);
-    assert (v[4] == 16u);
-}
-
-#[test]
-fn test_init_elt() {
-    // Test on-stack init_elt.
-    let v = vec::init_elt(10u, 2u);
-    assert (vec::len(v) == 2u);
-    assert (v[0] == 10u);
-    assert (v[1] == 10u);
-
-    // Test on-heap init_elt.
-    v = vec::init_elt(20u, 6u);
-    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() {
-    assert (vec::is_empty::<int>([]));
-    assert (!vec::is_empty([0]));
-}
-
-#[test]
-fn test_is_not_empty() {
-    assert (vec::is_not_empty([0]));
-    assert (!vec::is_not_empty::<int>([]));
-}
-
-#[test]
-fn test_head() {
-    let a = [11, 12];
-    check (vec::is_not_empty(a));
-    assert (vec::head(a) == 11);
-}
-
-#[test]
-fn test_tail() {
-    let a = [11];
-    check (vec::is_not_empty(a));
-    assert (vec::tail(a) == []);
-
-    a = [11, 12];
-    check (vec::is_not_empty(a));
-    assert (vec::tail(a) == [12]);
-}
-
-#[test]
-fn test_last() {
-    let n = vec::last([]);
-    assert (n == none);
-    n = vec::last([1, 2, 3]);
-    assert (n == some(3));
-    n = vec::last([1, 2, 3, 4, 5]);
-    assert (n == some(5));
-}
-
-#[test]
-fn test_slice() {
-    // Test on-stack -> on-stack slice.
-    let v = vec::slice([1, 2, 3], 1u, 3u);
-    assert (vec::len(v) == 2u);
-    assert (v[0] == 2);
-    assert (v[1] == 3);
-
-    // Test on-heap -> on-stack slice.
-    v = vec::slice([1, 2, 3, 4, 5], 0u, 3u);
-    assert (vec::len(v) == 3u);
-    assert (v[0] == 1);
-    assert (v[1] == 2);
-    assert (v[2] == 3);
-
-    // Test on-heap -> on-heap slice.
-    v = vec::slice([1, 2, 3, 4, 5, 6], 1u, 6u);
-    assert (vec::len(v) == 5u);
-    assert (v[0] == 2);
-    assert (v[1] == 3);
-    assert (v[2] == 4);
-    assert (v[3] == 5);
-    assert (v[4] == 6);
-}
-
-#[test]
-fn test_pop() {
-    // Test on-stack pop.
-    let v = [1, 2, 3];
-    let e = vec::pop(v);
-    assert (vec::len(v) == 2u);
-    assert (v[0] == 1);
-    assert (v[1] == 2);
-    assert (e == 3);
-
-    // Test on-heap pop.
-    v = [1, 2, 3, 4, 5];
-    e = vec::pop(v);
-    assert (vec::len(v) == 4u);
-    assert (v[0] == 1);
-    assert (v[1] == 2);
-    assert (v[2] == 3);
-    assert (v[3] == 4);
-    assert (e == 5);
-}
-
-#[test]
-fn test_push() {
-    // Test on-stack push().
-    let v = [];
-    vec::push(v, 1);
-    assert (vec::len(v) == 1u);
-    assert (v[0] == 1);
-
-    // Test on-heap push().
-    vec::push(v, 2);
-    assert (vec::len(v) == 2u);
-    assert (v[0] == 1);
-    assert (v[1] == 2);
-}
-
-#[test]
-fn test_grow() {
-    // Test on-stack grow().
-    let v = [];
-    vec::grow(v, 2u, 1);
-    assert (vec::len(v) == 2u);
-    assert (v[0] == 1);
-    assert (v[1] == 1);
-
-    // Test on-heap grow().
-    vec::grow(v, 3u, 2);
-    assert (vec::len(v) == 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 v = [];
-    vec::grow_fn(v, 3u, square);
-    assert (vec::len(v) == 3u);
-    assert (v[0] == 0u);
-    assert (v[1] == 1u);
-    assert (v[2] == 4u);
-}
-
-#[test]
-fn test_grow_set() {
-    let v = [mutable 1, 2, 3];
-    vec::grow_set(v, 4u, 4, 5);
-    assert (vec::len(v) == 5u);
-    assert (v[0] == 1);
-    assert (v[1] == 2);
-    assert (v[2] == 3);
-    assert (v[3] == 4);
-    assert (v[4] == 5);
-}
-
-#[test]
-fn test_map() {
-    // Test on-stack map.
-    let v = [1u, 2u, 3u];
-    let w = vec::map(v, square_ref);
-    assert (vec::len(w) == 3u);
-    assert (w[0] == 1u);
-    assert (w[1] == 4u);
-    assert (w[2] == 9u);
-
-    // Test on-heap map.
-    v = [1u, 2u, 3u, 4u, 5u];
-    w = vec::map(v, square_ref);
-    assert (vec::len(w) == 5u);
-    assert (w[0] == 1u);
-    assert (w[1] == 4u);
-    assert (w[2] == 9u);
-    assert (w[3] == 16u);
-    assert (w[4] == 25u);
-}
-
-#[test]
-fn test_map2() {
-    fn times(&&x: int, &&y: int) -> int { ret x * y; }
-    let f = times;
-    let v0 = [1, 2, 3, 4, 5];
-    let v1 = [5, 4, 3, 2, 1];
-    let u = vec::map2::<int, int, int>(v0, v1, f);
-    let i = 0;
-    while i < 5 { assert (v0[i] * v1[i] == u[i]); i += 1; }
-}
-
-#[test]
-fn test_filter_map() {
-    // Test on-stack filter-map.
-    let v = [1u, 2u, 3u];
-    let w = vec::filter_map(v, square_if_odd);
-    assert (vec::len(w) == 2u);
-    assert (w[0] == 1u);
-    assert (w[1] == 9u);
-
-    // Test on-heap filter-map.
-    v = [1u, 2u, 3u, 4u, 5u];
-    w = vec::filter_map(v, square_if_odd);
-    assert (vec::len(w) == 3u);
-    assert (w[0] == 1u);
-    assert (w[1] == 9u);
-    assert (w[2] == 25u);
-
-    fn halve(&&i: int) -> option::t<int> {
-        if i % 2 == 0 {
-            ret option::some::<int>(i / 2);
-        } else { ret option::none::<int>; }
-    }
-    fn halve_for_sure(&&i: int) -> int { ret i / 2; }
-    let all_even: [int] = [0, 2, 8, 6];
-    let all_odd1: [int] = [1, 7, 3];
-    let all_odd2: [int] = [];
-    let mix: [int] = [9, 2, 6, 7, 1, 0, 0, 3];
-    let mix_dest: [int] = [1, 3, 0, 0];
-    assert (filter_map(all_even, halve) == map(all_even, halve_for_sure));
-    assert (filter_map(all_odd1, halve) == []);
-    assert (filter_map(all_odd2, halve) == []);
-    assert (filter_map(mix, halve) == mix_dest);
-}
-
-#[test]
-fn test_filter() {
-    assert filter([1u, 2u, 3u], is_odd) == [1u, 3u];
-    assert filter([1u, 2u, 4u, 8u, 16u], is_three) == [];
-}
-
-#[test]
-fn test_foldl() {
-    // Test on-stack fold.
-    let v = [1u, 2u, 3u];
-    let sum = vec::foldl(0u, v, add);
-    assert (sum == 6u);
-
-    // Test on-heap fold.
-    v = [1u, 2u, 3u, 4u, 5u];
-    sum = vec::foldl(0u, v, add);
-    assert (sum == 15u);
-}
-
-#[test]
-fn test_foldl2() {
-    fn sub(&&a: int, &&b: int) -> int {
-        a - b
-    }
-    let v = [1, 2, 3, 4];
-    let sum = vec::foldl(0, v, sub);
-    assert sum == -10;
-}
-
-#[test]
-fn test_foldr() {
-    fn sub(&&a: int, &&b: int) -> int {
-        a - b
-    }
-    let v = [1, 2, 3, 4];
-    let sum = vec::foldr(v, 0, sub);
-    assert sum == -2;
-}
-
-#[test]
-fn iter_empty() {
-    let i = 0;
-    vec::iter::<int>([], { |_v| i += 1 });
-    assert i == 0;
-}
-
-#[test]
-fn iter_nonempty() {
-    let i = 0;
-    vec::iter([1, 2, 3], { |v| i += v });
-    assert i == 6;
-}
-
-#[test]
-fn iteri() {
-    let i = 0;
-    vec::iteri([1, 2, 3], { |j, v|
-        if i == 0 { assert v == 1; }
-        assert j + 1u == v as uint;
-        i += v;
-                          });
-    assert i == 6;
-}
-
-#[test]
-fn riter_empty() {
-    let i = 0;
-    vec::riter::<int>([], { |_v| i += 1 });
-    assert i == 0;
-}
-
-#[test]
-fn riter_nonempty() {
-    let i = 0;
-    vec::riter([1, 2, 3], { |v|
-        if i == 0 { assert v == 3; }
-        i += v
-                         });
-    assert i == 6;
-}
-
-#[test]
-fn riteri() {
-    let i = 0;
-    vec::riteri([0, 1, 2], { |j, v|
-        if i == 0 { assert v == 2; }
-        assert j == v as uint;
-        i += v;
-                          });
-    assert i == 3;
-}
-
-#[test]
-fn test_permute() {
-  let results: [[int]];
-
-  results = [];
-  permute([]) {|v| results += [v]; }
-  assert results == [[]];
-
-  results = [];
-  permute([7]) {|v| results += [v]; }
-  assert results == [[7]];
-
-  results = [];
-  permute([1,1]) {|v| results += [v]; }
-  assert results == [[1,1],[1,1]];
-
-  results = [];
-  permute([5,2,0]) {|v| results += [v]; }
-  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() {
-    assert (vec::any([1u, 2u, 3u], is_three));
-    assert (!vec::any([0u, 1u, 2u], is_three));
-    assert (vec::any([1u, 2u, 3u, 4u, 5u], is_three));
-    assert (!vec::any([1u, 2u, 4u, 5u, 6u], is_three));
-
-    assert (vec::all([3u, 3u, 3u], is_three));
-    assert (!vec::all([3u, 3u, 2u], is_three));
-    assert (vec::all([3u, 3u, 3u, 3u, 3u], is_three));
-    assert (!vec::all([3u, 3u, 0u, 1u, 2u], is_three));
-}
-
-#[test]
-fn test_any2_and_all2() {
-
-    assert (vec::any2([2u, 4u, 6u], [2u, 4u, 6u], is_equal));
-    assert (vec::any2([1u, 2u, 3u], [4u, 5u, 3u], is_equal));
-    assert (!vec::any2([1u, 2u, 3u], [4u, 5u, 6u], is_equal));
-    assert (vec::any2([2u, 4u, 6u], [2u, 4u], is_equal));
-
-    assert (vec::all2([2u, 4u, 6u], [2u, 4u, 6u], is_equal));
-    assert (!vec::all2([1u, 2u, 3u], [4u, 5u, 3u], is_equal));
-    assert (!vec::all2([1u, 2u, 3u], [4u, 5u, 6u], is_equal));
-    assert (!vec::all2([2u, 4u, 6u], [2u, 4u], is_equal));
-}
-
-#[test]
-fn test_zip_unzip() {
-    let v1 = [1, 2, 3];
-    let v2 = [4, 5, 6];
-
-    check (same_length(v1, v2)); // Silly, but what else can we do?
-    let z1 = vec::zip(v1, v2);
-
-    assert ((1, 4) == z1[0]);
-    assert ((2, 5) == z1[1]);
-    assert ((3, 6) == z1[2]);
-
-    let (left, right) = vec::unzip(z1);
-
-    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() {
-    let v1: [int] = [1, 2, 3, 3, 2, 5];
-    assert (position(1, v1) == option::some::<uint>(0u));
-    assert (position(2, v1) == option::some::<uint>(1u));
-    assert (position(5, v1) == option::some::<uint>(5u));
-    assert (position(4, v1) == option::none::<uint>);
-}
-
-#[test]
-fn test_position_pred() {
-    fn less_than_three(&&i: int) -> bool { ret i < 3; }
-    fn is_eighteen(&&i: int) -> bool { ret i == 18; }
-    let v1: [int] = [5, 4, 3, 2, 1];
-    assert (position_pred(v1, less_than_three) == option::some::<uint>(3u));
-    assert (position_pred(v1, is_eighteen) == option::none::<uint>);
-}
-
-#[test]
-fn reverse_and_reversed() {
-    let v: [mutable int] = [mutable 10, 20];
-    assert (v[0] == 10);
-    assert (v[1] == 20);
-    vec::reverse(v);
-    assert (v[0] == 20);
-    assert (v[1] == 10);
-    let v2 = vec::reversed::<int>([10, 20]);
-    assert (v2[0] == 20);
-    assert (v2[1] == 10);
-    v[0] = 30;
-    assert (v2[0] == 20);
-    // Make sure they work with 0-length vectors too.
-
-    let v4 = vec::reversed::<int>([]);
-    assert (v4 == []);
-    let v3: [mutable int] = [mutable];
-    vec::reverse::<int>(v3);
-}
-
-#[test]
-fn reversed_mut() {
-    let v2 = vec::reversed::<int>([mutable 10, 20]);
-    assert (v2[0] == 20);
-    assert (v2[1] == 10);
-}
-
-#[test]
-fn init() {
-    let v = vec::init([1, 2, 3]);
-    assert v == [1, 2];
-}
-
-#[test]
-// FIXME: Windows can't undwind
-#[ignore(cfg(target_os = "win32"))]
-fn init_empty() {
-
-    let r = task::join(
-        task::spawn_joinable {||
-            task::unsupervise();
-            vec::init::<int>([]);
-        });
-    assert r == task::tr_failure
-}
-
-#[test]
-fn concat() {
-    assert vec::concat([[1], [2,3]]) == [1, 2, 3];
-}
-
-// Local Variables:
-// mode: rust;
-// fill-column: 78;
-// indent-tabs-mode: nil
-// c-basic-offset: 4
-// buffer-file-coding-system: utf-8-unix
-// End:
-