2011-06-24 16:19:58 -05:00
|
|
|
// Binop corner cases
|
|
|
|
|
2011-08-11 00:25:23 -05:00
|
|
|
use std;
|
|
|
|
import std::unsafe::reinterpret_cast;
|
2011-08-13 17:20:11 -05:00
|
|
|
import std::task;
|
2011-08-15 18:54:02 -05:00
|
|
|
import std::comm;
|
2011-08-11 00:25:23 -05:00
|
|
|
|
2011-06-24 16:19:58 -05:00
|
|
|
fn test_nil() {
|
2011-07-27 07:19:39 -05:00
|
|
|
assert (() == ());
|
|
|
|
assert (!(() != ()));
|
|
|
|
assert (!(() < ()));
|
|
|
|
assert (() <= ());
|
|
|
|
assert (!(() > ()));
|
|
|
|
assert (() >= ());
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_bool() {
|
2011-07-27 07:19:39 -05:00
|
|
|
assert (!(true < false));
|
|
|
|
assert (!(true <= false));
|
|
|
|
assert (true > false);
|
|
|
|
assert (true >= false);
|
|
|
|
|
|
|
|
assert (false < true);
|
|
|
|
assert (false <= true);
|
|
|
|
assert (!(false > true));
|
|
|
|
assert (!(false >= true));
|
|
|
|
|
|
|
|
// Bools support bitwise binops
|
|
|
|
assert (false & false == false);
|
|
|
|
assert (true & false == false);
|
|
|
|
assert (true & true == true);
|
|
|
|
assert (false | false == false);
|
|
|
|
assert (true | false == true);
|
|
|
|
assert (true | true == true);
|
|
|
|
assert (false ^ false == false);
|
|
|
|
assert (true ^ false == true);
|
|
|
|
assert (true ^ true == false);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_char() {
|
2011-07-27 07:19:39 -05:00
|
|
|
let ch10 = 10 as char;
|
|
|
|
let ch4 = 4 as char;
|
|
|
|
let ch2 = 2 as char;
|
|
|
|
assert (ch10 + ch4 == 14 as char);
|
|
|
|
assert (ch10 - ch4 == 6 as char);
|
|
|
|
assert (ch10 * ch4 == 40 as char);
|
|
|
|
assert (ch10 / ch4 == ch2);
|
|
|
|
assert (ch10 % ch4 == ch2);
|
|
|
|
assert (ch10 >> ch2 == ch2);
|
|
|
|
assert (ch10 >>> ch2 == ch2);
|
|
|
|
assert (ch10 << ch4 == 160 as char);
|
|
|
|
assert (ch10 | ch4 == 14 as char);
|
|
|
|
assert (ch10 & ch2 == ch2);
|
|
|
|
assert (ch10 ^ ch2 == 8 as char);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_box() {
|
2011-08-12 17:14:17 -05:00
|
|
|
assert (@10 == @10);
|
|
|
|
assert (@{a: 1, b: 3} < @{a: 1, b: 4});
|
2011-07-27 07:19:39 -05:00
|
|
|
assert (@{a: 'x'} != @{a: 'y'});
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_port() {
|
2011-08-13 02:10:18 -05:00
|
|
|
let p1 = comm::mk_port::<int>();
|
|
|
|
let p2 = comm::mk_port::<int>();
|
2011-06-24 16:19:58 -05:00
|
|
|
|
2011-08-19 17:16:48 -05:00
|
|
|
assert (p1 == p1);
|
|
|
|
assert (p1 != p2);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_chan() {
|
2011-08-10 11:27:22 -05:00
|
|
|
let p: comm::_port<int> = comm::mk_port();
|
2011-08-15 18:54:02 -05:00
|
|
|
let ch1 = p.mk_chan();
|
|
|
|
let ch2 = p.mk_chan();
|
2011-06-24 16:19:58 -05:00
|
|
|
|
2011-08-19 17:16:48 -05:00
|
|
|
assert (ch1 == ch1);
|
2011-08-15 18:54:02 -05:00
|
|
|
// Chans are equal because they are just task:port addresses.
|
2011-08-19 17:16:48 -05:00
|
|
|
assert (ch1 == ch2);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_ptr() {
|
2011-07-27 07:19:39 -05:00
|
|
|
// FIXME: Don't know what binops apply to pointers. Don't know how
|
|
|
|
// to make or use pointers
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_task() {
|
2011-07-27 07:19:39 -05:00
|
|
|
fn f() { }
|
2011-08-17 13:44:35 -05:00
|
|
|
let f1 = f, f2 = f;
|
|
|
|
let t1 = task::spawn(f1);
|
|
|
|
let t2 = task::spawn(f2);
|
2011-08-11 00:25:23 -05:00
|
|
|
|
2011-08-19 17:16:48 -05:00
|
|
|
assert (t1 == t1);
|
|
|
|
assert (t1 != t2);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_fn() {
|
2011-07-27 07:19:39 -05:00
|
|
|
fn f() { }
|
|
|
|
fn g() { }
|
|
|
|
fn h(i: int) { }
|
|
|
|
let f1 = f;
|
|
|
|
let f2 = f;
|
|
|
|
let g1 = g;
|
|
|
|
let h1 = h;
|
|
|
|
let h2 = h;
|
|
|
|
assert (f1 == f2);
|
|
|
|
assert (f1 == f);
|
|
|
|
|
2011-08-09 18:28:10 -05:00
|
|
|
assert (f1 != g1);
|
2011-07-27 07:19:39 -05:00
|
|
|
assert (h1 == h2);
|
|
|
|
assert (!(f1 != f2));
|
|
|
|
assert (!(h1 < h2));
|
|
|
|
assert (h1 <= h2);
|
|
|
|
assert (!(h1 > h2));
|
|
|
|
assert (h1 >= h2);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
2011-06-28 07:21:13 -05:00
|
|
|
native "rust" mod native_mod = "" {
|
2011-08-17 18:01:23 -05:00
|
|
|
fn str_byte_len(s: str) -> uint;
|
2011-08-11 00:25:23 -05:00
|
|
|
// This isn't actually the signature of str_alloc, but since
|
|
|
|
// we're not calling it that shouldn't matter
|
2011-08-17 18:01:23 -05:00
|
|
|
fn str_alloc(s: str) -> uint;
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// FIXME: comparison of native fns
|
|
|
|
fn test_native_fn() {
|
2011-08-11 00:25:23 -05:00
|
|
|
assert (native_mod::str_byte_len == native_mod::str_byte_len);
|
|
|
|
assert (native_mod::str_byte_len != native_mod::str_alloc);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn test_obj() {
|
2011-08-19 17:16:48 -05:00
|
|
|
let o1 = obj () { };
|
|
|
|
let o2 = obj () { };
|
2011-07-27 07:19:39 -05:00
|
|
|
|
2011-08-11 00:25:23 -05:00
|
|
|
assert (o1 == o1);
|
|
|
|
|
|
|
|
// FIXME (#815): This doesn't work on linux only. Wierd.
|
|
|
|
//assert (o1 != o2);
|
|
|
|
//assert (!(o1 == o2));
|
2011-07-27 07:19:39 -05:00
|
|
|
|
|
|
|
obj constr1(i: int) { }
|
|
|
|
obj constr2(i: int) { }
|
|
|
|
|
|
|
|
let o5 = constr1(10);
|
|
|
|
let o6 = constr1(10);
|
|
|
|
let o7 = constr1(11);
|
|
|
|
let o8 = constr2(11);
|
|
|
|
|
2011-08-09 18:28:10 -05:00
|
|
|
assert (o5 != o6);
|
|
|
|
assert (o6 != o7);
|
|
|
|
assert (o7 != o8);
|
2011-06-24 16:19:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn main() {
|
2011-07-27 07:19:39 -05:00
|
|
|
test_nil();
|
|
|
|
test_bool();
|
|
|
|
test_char();
|
|
|
|
test_box();
|
|
|
|
test_port();
|
|
|
|
test_chan();
|
|
|
|
test_ptr();
|
|
|
|
test_task();
|
|
|
|
test_fn();
|
|
|
|
test_native_fn();
|
|
|
|
test_obj();
|
2011-08-09 18:28:10 -05:00
|
|
|
}
|