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