1require 'test/unit' 2 3class TestFixnum < Test::Unit::TestCase 4 def setup 5 @verbose = $VERBOSE 6 $VERBOSE = nil 7 end 8 9 def teardown 10 $VERBOSE = @verbose 11 end 12 13 def test_pow 14 [1, 2, 2**64, 2**63*3, 2**64*3].each do |y| 15 [-1, 0, 1].each do |x| 16 z1 = x**y 17 z2 = (-x)**y 18 if y % 2 == 1 19 assert_equal(z2, -z1) 20 else 21 assert_equal(z2, z1) 22 end 23 end 24 end 25 end 26 27 def test_succ 28 assert_equal(0x40000000, 0x3fffffff.succ, "[ruby-dev:31189]") 29 assert_equal(0x4000000000000000, 0x3fffffffffffffff.succ, "[ruby-dev:31190]") 30 end 31 32 def test_pred 33 assert_equal(-0x40000001, (-0x40000000).pred) 34 assert_equal(-0x4000000000000001, (-0x4000000000000000).pred) 35 end 36 37 def test_plus 38 assert_equal(0x40000000, 0x3fffffff+1) 39 assert_equal(0x4000000000000000, 0x3fffffffffffffff+1) 40 assert_equal(-0x40000001, (-0x40000000)+(-1)) 41 assert_equal(-0x4000000000000001, (-0x4000000000000000)+(-1)) 42 assert_equal(-0x80000000, (-0x40000000)+(-0x40000000)) 43 end 44 45 def test_sub 46 assert_equal(0x40000000, 0x3fffffff-(-1)) 47 assert_equal(0x4000000000000000, 0x3fffffffffffffff-(-1)) 48 assert_equal(-0x40000001, (-0x40000000)-1) 49 assert_equal(-0x4000000000000001, (-0x4000000000000000)-1) 50 assert_equal(-0x80000000, (-0x40000000)-0x40000000) 51 end 52 53 def test_mult 54 assert_equal(0x40000000, 0x20000000*2) 55 assert_equal(0x4000000000000000, 0x2000000000000000*2) 56 assert_equal(-0x40000001, 33025*(-32513)) 57 assert_equal(-0x4000000000000001, 1380655685*(-3340214413)) 58 assert_equal(0x40000000, (-0x40000000)*(-1)) 59 end 60 61 def test_div 62 assert_equal(2, 5/2) 63 assert_equal(0, 1/2) 64 assert_equal(-1, -1/2) 65 assert_equal(0, -(1/2)) 66 assert_equal(-1, (-1)/2) 67 assert_equal(0, (-1)/(-2)) 68 assert_equal(-1, 1/(-2)) 69 assert_equal(1, -(1/(-2))) 70 assert_equal(0x3fffffff, 0xbffffffd/3) 71 assert_equal(0x40000000, 0xc0000000/3) 72 assert_equal(0x4000000000000000, 0xc000000000000000/3) 73 assert_equal(-0x40000001, 0xc0000003/(-3)) 74 assert_equal(-0x4000000000000001, 0xc000000000000003/(-3)) 75 assert_equal(0x40000000, (-0x40000000)/(-1), "[ruby-dev:31210]") 76 assert_equal(0x4000000000000000, (-0x4000000000000000)/(-1)) 77 end 78 79 def test_mod 80 assert_equal(2, (-0x40000000) % 3) 81 assert_equal(0, (-0x40000000) % (-1)) 82 end 83 84 def test_divmod 85 (-5).upto(5) {|a| 86 (-5).upto(5) {|b| 87 next if b == 0 88 q, r = a.divmod(b) 89 assert_equal(a, b*q+r) 90 assert(r.abs < b.abs) 91 assert(0 < b ? (0 <= r && r < b) : (b < r && r <= 0)) 92 assert_equal(q, a/b) 93 assert_equal(q, a.div(b)) 94 assert_equal(r, a%b) 95 assert_equal(r, a.modulo(b)) 96 } 97 } 98 end 99 100 def test_not 101 assert_equal(-0x40000000, ~0x3fffffff) 102 assert_equal(0x3fffffff, ~-0x40000000) 103 end 104 105 def test_lshift 106 assert_equal(0x40000000, 0x20000000 << 1) 107 assert_equal(-0x40000000, (-0x20000000) << 1) 108 assert_equal(-0x80000000, (-0x40000000) << 1) 109 end 110 111 def test_rshift 112 assert_equal(0x20000000, 0x40000000 >> 1) 113 assert_equal(-0x20000000, (-0x40000000) >> 1) 114 assert_equal(-0x40000000, (-0x80000000) >> 1) 115 end 116 117 def test_abs 118 assert_equal(0x40000000, (-0x40000000).abs) 119 assert_equal(0x4000000000000000, (-0x4000000000000000).abs) 120 end 121 122 def test_to_s 123 assert_equal("1010", 10.to_s(2)) 124 assert_equal("a", 10.to_s(36)) 125 assert_raise(ArgumentError) { 10.to_s(1) } 126 end 127 128 def test_plus2 129 assert_equal(2, 1 + 1) 130 assert_equal(4294967297, 1 + 2**32) 131 assert_equal(2.0, 1 + 1.0) 132 assert_raise(TypeError) { 1 + nil } 133 end 134 135 def test_minus 136 assert_equal(0, 1 - 1) 137 assert_equal(-4294967295, 1 - 2**32) 138 assert_equal(0.0, 1 - 1.0) 139 assert_raise(TypeError) { 1 - nil } 140 end 141 142 def test_mul 143 assert_equal(6, 2.send(:*, 3)) 144 a = 2**30-1 145 assert_equal(1152921502459363329, a.send(:*, a)) 146 147 assert_equal(6.0, 2 * 3.0) 148 assert_raise(TypeError) { 2 * nil } 149 end 150 151 def test_divide 152 assert_equal(2.0, 4.quo(2)) 153 assert_equal(2.0, 4 / 2) 154 assert_equal(2.0, 4.div(2)) 155 156 assert_equal(0.5**32, 1.quo(2**32)) 157 assert_equal(0, 1 / (2**32)) 158 assert_equal(0, 1.div(2**32)) 159 160 assert_equal(0.5, 1.quo(2.0)) 161 assert_equal(0.5, 1 / 2.0) 162 assert_equal(0, 1.div(2.0)) 163 164 ### rational changes the behavior of Fixnum#quo 165 #assert_raise(TypeError) { 2.quo(nil) } 166 assert_raise(TypeError, NoMethodError) { 2.quo(nil) } 167 assert_raise(TypeError) { 2 / nil } 168 assert_raise(TypeError) { 2.div(nil) } 169 170 assert_equal(0, 4.modulo(2)) 171 assert_equal(1, 1.modulo(2**32)) 172 assert_equal(1, 1.modulo(2.0)) 173 assert_raise(TypeError) { 2.modulo(nil) } 174 175 assert_equal([2, 0], 4.divmod(2)) 176 assert_equal([0, 1], 1.divmod(2**32)) 177 assert_equal([0, 1], 1.divmod(2.0)) 178 assert_raise(TypeError) { 2.divmod(nil) } 179 end 180 181 def test_pow2 182 assert_equal(65536, 2**16) 183 assert_equal(4294967296, 2**32) 184 assert_equal(0.5**16, 2**-16) 185 assert_equal(1, (-1)**4294967296) 186 assert_equal(-1, (-1)**4294967295) 187 assert_equal(4, 2**((2**32).coerce(2).first)) 188 assert_equal(2, 4**0.5) 189 assert_equal(0, 0**0.5) 190 assert_equal(1, (0**-1.0).infinite?) 191 ### rational changes the behavior of Fixnum#** 192 #assert_raise(TypeError) { 1 ** nil } 193 assert_raise(TypeError, NoMethodError) { 1 ** nil } 194 end 195 196 def test_cmp 197 assert(1 != nil) 198 199 assert_equal(0, 1 <=> 1) 200 assert_equal(-1, 1 <=> 4294967296) 201 assert_equal(0, 1 <=> 1.0) 202 assert_nil(1 <=> nil) 203 204 assert(1.send(:>, 0)) 205 assert(!(1.send(:>, 1))) 206 assert(!(1.send(:>, 2))) 207 assert(!(1.send(:>, 4294967296))) 208 assert(1.send(:>, 0.0)) 209 assert_raise(ArgumentError) { 1.send(:>, nil) } 210 211 assert(1.send(:>=, 0)) 212 assert(1.send(:>=, 1)) 213 assert(!(1.send(:>=, 2))) 214 assert(!(1.send(:>=, 4294967296))) 215 assert(1.send(:>=, 0.0)) 216 assert_raise(ArgumentError) { 1.send(:>=, nil) } 217 218 assert(!(1.send(:<, 0))) 219 assert(!(1.send(:<, 1))) 220 assert(1.send(:<, 2)) 221 assert(1.send(:<, 4294967296)) 222 assert(!(1.send(:<, 0.0))) 223 assert_raise(ArgumentError) { 1.send(:<, nil) } 224 225 assert(!(1.send(:<=, 0))) 226 assert(1.send(:<=, 1)) 227 assert(1.send(:<=, 2)) 228 assert(1.send(:<=, 4294967296)) 229 assert(!(1.send(:<=, 0.0))) 230 assert_raise(ArgumentError) { 1.send(:<=, nil) } 231 end 232 233 class DummyNumeric < Numeric 234 def to_int 235 1 236 end 237 end 238 239 def test_and_with_float 240 assert_raise(TypeError) { 1 & 1.5 } 241 end 242 243 def test_and_with_rational 244 assert_raise(TypeError, "#1792") { 1 & Rational(3, 2) } 245 end 246 247 def test_and_with_nonintegral_numeric 248 assert_raise(TypeError, "#1792") { 1 & DummyNumeric.new } 249 end 250 251 def test_or_with_float 252 assert_raise(TypeError) { 1 | 1.5 } 253 end 254 255 def test_or_with_rational 256 assert_raise(TypeError, "#1792") { 1 | Rational(3, 2) } 257 end 258 259 def test_or_with_nonintegral_numeric 260 assert_raise(TypeError, "#1792") { 1 | DummyNumeric.new } 261 end 262 263 def test_xor_with_float 264 assert_raise(TypeError) { 1 ^ 1.5 } 265 end 266 267 def test_xor_with_rational 268 assert_raise(TypeError, "#1792") { 1 ^ Rational(3, 2) } 269 end 270 271 def test_xor_with_nonintegral_numeric 272 assert_raise(TypeError, "#1792") { 1 ^ DummyNumeric.new } 273 end 274 275 def test_singleton_method 276 assert_raise(TypeError) { a = 1; def a.foo; end } 277 end 278 279 def test_frozen 280 assert_equal(true, 1.frozen?) 281 end 282 283 def assert_eql(a, b, mess) 284 assert a.eql?(b), "expected #{a} & #{b} to be eql? #{mess}" 285 end 286 287 def test_power_of_1_and_minus_1 288 bug5715 = '[ruby-core:41498]' 289 big = 1 << 66 290 assert_eql 1, 1 ** -big , bug5715 291 assert_eql 1, (-1) ** -big , bug5715 292 assert_eql -1, (-1) ** -(big+1) , bug5715 293 end 294 295 def test_power_of_0 296 bug5713 = '[ruby-core:41494]' 297 big = 1 << 66 298 assert_raise(ZeroDivisionError, bug5713) { 0 ** -big } 299 assert_raise(ZeroDivisionError, bug5713) { 0 ** Rational(-2,3) } 300 end 301end 302