diff options
35 files changed, 1990 insertions, 2068 deletions
diff --git a/src/libcore/bool.rs b/src/libcore/bool.rs index fa8a5d2e7c0..3b358011422 100644 --- a/src/libcore/bool.rs +++ b/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; diff --git a/src/libcore/box.rs b/src/libcore/box.rs index fefc129c8b0..114c495d64d 100644 --- a/src/libcore/box.rs +++ b/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)); +} diff --git a/src/libcore/char.rs b/src/libcore/char.rs index 2c46c652cd0..1903ac8dbd8 100644 --- a/src/libcore/char.rs +++ b/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('ß') == 'ß'); +} diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs index f9e95edf5e2..353c14fe5a8 100644 --- a/src/libcore/comm.rs +++ b/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); +} + diff --git a/src/libcore/either.rs b/src/libcore/either.rs index e6956930686..47878ae9bf4 100644 --- a/src/libcore/either.rs +++ b/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); +} diff --git a/src/libcore/float.rs b/src/libcore/float.rs index 17d5fb1f7f6..4023c65b118 100644 --- a/src/libcore/float.rs +++ b/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 diff --git a/src/libcore/int.rs b/src/libcore/int.rs index 1ab22b3e06c..ca48e83011c 100644 --- a/src/libcore/int.rs +++ b/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; diff --git a/src/libcore/math.rs b/src/libcore/math.rs index 9c83ce04bfe..c2982cf918a 100644 --- a/src/libcore/math.rs +++ b/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; +} + +*/ \ No newline at end of file diff --git a/src/libcore/option.rs b/src/libcore/option.rs index 453f38567a8..1dcfed5bc36 100644 --- a/src/libcore/option.rs +++ b/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; diff --git a/src/libcore/ptr.rs b/src/libcore/ptr.rs index 0372b17cdf1..8ce0730df4f 100644 --- a/src/libcore/ptr.rs +++ b/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); +} \ No newline at end of file diff --git a/src/libcore/result.rs b/src/libcore/result.rs index 52af0421e58..7cb24a7d3d3 100644 --- a/src/libcore/result.rs +++ b/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"; + } +} diff --git a/src/libcore/str.rs b/src/libcore/str.rs index fa0f9b334dc..b24c2158d41 100644 --- a/src/libcore/str.rs +++ b/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"); + } +} \ No newline at end of file diff --git a/src/libcore/sys.rs b/src/libcore/sys.rs index f022532eefc..7360ca3521a 100644 --- a/src/libcore/sys.rs +++ b/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; diff --git a/src/libcore/task.rs b/src/libcore/task.rs index b24e27596b5..6f3e7b0f065 100644 --- a/src/libcore/task.rs +++ b/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; diff --git a/src/libcore/uint.rs b/src/libcore/uint.rs index ee28c07de3d..598c6baffe4 100644 --- a/src/libcore/uint.rs +++ b/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; diff --git a/src/libcore/unsafe.rs b/src/libcore/unsafe.rs index 22cce495649..b069c62d41e 100644 --- a/src/libcore/unsafe.rs +++ b/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); + } +} diff --git a/src/libcore/vec.rs b/src/libcore/vec.rs index e7b0a2b9ae2..c4ddde19e94 100644 --- a/src/libcore/vec.rs +++ b/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; diff --git a/src/test/stdtest/bool.rs b/src/test/stdtest/bool.rs deleted file mode 100644 index 528e8e42681..00000000000 --- a/src/test/stdtest/bool.rs +++ /dev/null @@ -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 }; - } -} \ No newline at end of file diff --git a/src/test/stdtest/box.rs b/src/test/stdtest/box.rs deleted file mode 100644 index abe80eec997..00000000000 --- a/src/test/stdtest/box.rs +++ /dev/null @@ -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)); -} diff --git a/src/test/stdtest/char.rs b/src/test/stdtest/char.rs deleted file mode 100644 index 7da2443d6c2..00000000000 --- a/src/test/stdtest/char.rs +++ /dev/null @@ -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('ß') == 'ß'); -} diff --git a/src/test/stdtest/comm.rs b/src/test/stdtest/comm.rs deleted file mode 100644 index fbb0cec73c9..00000000000 --- a/src/test/stdtest/comm.rs +++ /dev/null @@ -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); -} diff --git a/src/test/stdtest/either.rs b/src/test/stdtest/either.rs deleted file mode 100644 index de5849f029f..00000000000 --- a/src/test/stdtest/either.rs +++ /dev/null @@ -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); -} diff --git a/src/test/stdtest/float.rs b/src/test/stdtest/float.rs deleted file mode 100644 index 3ac3d67b834..00000000000 --- a/src/test/stdtest/float.rs +++ /dev/null @@ -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)); -} diff --git a/src/test/stdtest/int.rs b/src/test/stdtest/int.rs deleted file mode 100644 index c8ec806189f..00000000000 --- a/src/test/stdtest/int.rs +++ /dev/null @@ -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); -} diff --git a/src/test/stdtest/math.rs b/src/test/stdtest/math.rs deleted file mode 100644 index adb68e4198c..00000000000 --- a/src/test/stdtest/math.rs +++ /dev/null @@ -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; -} - -*/ \ No newline at end of file diff --git a/src/test/stdtest/option.rs b/src/test/stdtest/option.rs deleted file mode 100644 index a04751da101..00000000000 --- a/src/test/stdtest/option.rs +++ /dev/null @@ -1,6 +0,0 @@ -import core::*; - -use std; - -#[test] -fn test() { let _x = option::some::<int>(10); } diff --git a/src/test/stdtest/ptr.rs b/src/test/stdtest/ptr.rs deleted file mode 100644 index a2242b1a06d..00000000000 --- a/src/test/stdtest/ptr.rs +++ /dev/null @@ -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); -} - diff --git a/src/test/stdtest/result.rs b/src/test/stdtest/result.rs deleted file mode 100644 index ed041349176..00000000000 --- a/src/test/stdtest/result.rs +++ /dev/null @@ -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"; -} \ No newline at end of file diff --git a/src/test/stdtest/stdtest.rc b/src/test/stdtest/stdtest.rc index ff2af295a26..4fd390c5c3e 100644 --- a/src/test/stdtest/stdtest.rc +++ b/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 diff --git a/src/test/stdtest/str.rs b/src/test/stdtest/str.rs deleted file mode 100644 index 26b5c2e9df7..00000000000 --- a/src/test/stdtest/str.rs +++ /dev/null @@ -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"); -} diff --git a/src/test/stdtest/sys.rs b/src/test/stdtest/sys.rs deleted file mode 100644 index 632f42c0f6b..00000000000 --- a/src/test/stdtest/sys.rs +++ /dev/null @@ -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; -} \ No newline at end of file diff --git a/src/test/stdtest/task.rs b/src/test/stdtest/task.rs deleted file mode 100644 index 021a56a5dff..00000000000 --- a/src/test/stdtest/task.rs +++ /dev/null @@ -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; } - } -} \ No newline at end of file diff --git a/src/test/stdtest/uint.rs b/src/test/stdtest/uint.rs deleted file mode 100644 index 43187994829..00000000000 --- a/src/test/stdtest/uint.rs +++ /dev/null @@ -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); -} \ No newline at end of file diff --git a/src/test/stdtest/unsafe.rs b/src/test/stdtest/unsafe.rs deleted file mode 100644 index b8197cf4c23..00000000000 --- a/src/test/stdtest/unsafe.rs +++ /dev/null @@ -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); -} \ No newline at end of file diff --git a/src/test/stdtest/vec.rs b/src/test/stdtest/vec.rs deleted file mode 100644 index 3bbea1db6be..00000000000 --- a/src/test/stdtest/vec.rs +++ /dev/null @@ -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: - |