/src/test/run-pass/binops.rs

http://github.com/jruderman/rust · Rust · 162 lines · 136 code · 21 blank · 5 comment · 40 complexity · 21c92a84548487f36fa095467a356f0b MD5 · raw file

  1. // Binop corner cases
  2. use std;
  3. import unsafe::reinterpret_cast;
  4. import task;
  5. import comm;
  6. fn test_nil() {
  7. assert (() == ());
  8. assert (!(() != ()));
  9. assert (!(() < ()));
  10. assert (() <= ());
  11. assert (!(() > ()));
  12. assert (() >= ());
  13. }
  14. fn test_bool() {
  15. assert (!(true < false));
  16. assert (!(true <= false));
  17. assert (true > false);
  18. assert (true >= false);
  19. assert (false < true);
  20. assert (false <= true);
  21. assert (!(false > true));
  22. assert (!(false >= true));
  23. // Bools support bitwise binops
  24. assert (false & false == false);
  25. assert (true & false == false);
  26. assert (true & true == true);
  27. assert (false | false == false);
  28. assert (true | false == true);
  29. assert (true | true == true);
  30. assert (false ^ false == false);
  31. assert (true ^ false == true);
  32. assert (true ^ true == false);
  33. }
  34. fn test_char() {
  35. let ch10 = 10 as char;
  36. let ch4 = 4 as char;
  37. let ch2 = 2 as char;
  38. assert (ch10 + ch4 == 14 as char);
  39. assert (ch10 - ch4 == 6 as char);
  40. assert (ch10 * ch4 == 40 as char);
  41. assert (ch10 / ch4 == ch2);
  42. assert (ch10 % ch4 == ch2);
  43. assert (ch10 >> ch2 == ch2);
  44. assert (ch10 << ch4 == 160 as char);
  45. assert (ch10 | ch4 == 14 as char);
  46. assert (ch10 & ch2 == ch2);
  47. assert (ch10 ^ ch2 == 8 as char);
  48. }
  49. fn test_box() {
  50. assert (@10 == @10);
  51. assert (@{a: 1, b: 3} < @{a: 1, b: 4});
  52. assert (@{a: 'x'} != @{a: 'y'});
  53. }
  54. fn test_port() {
  55. let p1 = comm::port::<int>();
  56. let p2 = comm::port::<int>();
  57. assert (p1 == p1);
  58. assert (p1 != p2);
  59. }
  60. fn test_chan() {
  61. let p: comm::port<int> = comm::port();
  62. let ch1 = comm::chan(p);
  63. let ch2 = comm::chan(p);
  64. assert (ch1 == ch1);
  65. // Chans are equal because they are just task:port addresses.
  66. assert (ch1 == ch2);
  67. }
  68. fn test_ptr() unsafe {
  69. let p1: *u8 = unsafe::reinterpret_cast(0);
  70. let p2: *u8 = unsafe::reinterpret_cast(0);
  71. let p3: *u8 = unsafe::reinterpret_cast(1);
  72. assert p1 == p2;
  73. assert p1 != p3;
  74. assert p1 < p3;
  75. assert p1 <= p3;
  76. assert p3 > p1;
  77. assert p3 >= p3;
  78. assert p1 <= p2;
  79. assert p1 >= p2;
  80. }
  81. fn test_fn() {
  82. fn f() { }
  83. fn g() { }
  84. fn h(_i: int) { }
  85. let f1 = f;
  86. let f2 = f;
  87. let g1 = g;
  88. let h1 = h;
  89. let h2 = h;
  90. assert (f1 == f2);
  91. assert (f1 == f);
  92. assert (f1 != g1);
  93. assert (h1 == h2);
  94. assert (!(f1 != f2));
  95. assert (!(h1 < h2));
  96. assert (h1 <= h2);
  97. assert (!(h1 > h2));
  98. assert (h1 >= h2);
  99. }
  100. #[abi = "cdecl"]
  101. #[nolink]
  102. extern mod test {
  103. fn rust_get_sched_id() -> libc::intptr_t;
  104. fn get_task_id() -> libc::intptr_t;
  105. }
  106. fn test_foreign_fn() {
  107. assert test::rust_get_sched_id != test::get_task_id;
  108. assert test::rust_get_sched_id == test::rust_get_sched_id;
  109. }
  110. class p {
  111. let mut x: int;
  112. let mut y: int;
  113. new(x: int, y: int) { self.x = x; self.y = y; }
  114. }
  115. fn test_class() {
  116. let q = p(1, 2);
  117. let r = p(1, 2);
  118. unsafe {
  119. error!{"q = %x, r = %x",
  120. (unsafe::reinterpret_cast::<*p, uint>(ptr::addr_of(q))),
  121. (unsafe::reinterpret_cast::<*p, uint>(ptr::addr_of(r)))};
  122. }
  123. assert(q == r);
  124. r.y = 17;
  125. assert(r.y != q.y);
  126. assert(r.y == 17);
  127. assert(q != r);
  128. }
  129. fn main() {
  130. test_nil();
  131. test_bool();
  132. test_char();
  133. test_box();
  134. // FIXME: test_port causes valgrind errors (#2724)
  135. //test_port();
  136. test_chan();
  137. test_ptr();
  138. test_fn();
  139. test_foreign_fn();
  140. test_class();
  141. }