libcore: Move core tests into libcore

Author: brson

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