Exhaustive test for bignum.c

e$B1sF#$H?=$7$^$9!#e(B

test_bignum.rb e$B$K%F%9%[email protected]$r>e$2$F$_$^$7$?!#e(B
gcov e$B$G$Ne(B bignum.c e$B$N%+%P%l%C%8$,e(B 50% e$B$+$ie(B 90%
e$B$K$J$j$^$9!#e(B
e$B$I$&$G$7$g$&$+!#e(B

$ ./ruby test/ruby/test_bignum.rb
Loaded suite test/ruby/test_bignum
Started
…test/ruby/test_bignum.rb:251: warning: in
ab, b may be too big
test/ruby/test_bignum.rb:252: warning: in a
b, b may be too big
…/home/mame/work/ruby19/gcov/local/lib/ruby/1.9.0/test/unit/assertions.rb:83:
warning: Bignum out of Float range
/home/mame/work/ruby19/gcov/local/lib/ruby/1.9.0/test/unit/assertions.rb:83:
warning: Bignum out of Float range
/home/mame/work/ruby19/gcov/local/lib/ruby/1.9.0/test/unit/assertions.rb:83:
warning: Bignum out of Float range
…test/ruby/test_bignum.rb:162: warning: Bignum out of Float range

Finished in 2.3600356 seconds.

37 tests, 299 assertions, 0 failures, 0 errors

$ gcov bignum.c
File ‘/usr/include/sys/sysmacros.h’
Lines executed:0.00% of 6
/usr/include/sys/sysmacros.h:creating ‘sysmacros.h.gcov’

File ‘./include/ruby/ruby.h’
Lines executed:45.45% of 22
./include/ruby/ruby.h:creating ‘ruby.h.gcov’

File ‘bignum.c’
Lines executed:93.01% of 1187
bignum.c:creating ‘bignum.c.gcov’

Index: test/ruby/test_bignum.rb

— test/ruby/test_bignum.rb (revision 15159)
+++ test/ruby/test_bignum.rb (working copy)
@@ -95,4 +95,257 @@
assert_equal(“1777777777777777777777”
,18446744073709551615.to_s(8))
assert_equal("-1777777777777777777777"
,-18446744073709551615.to_s(8))
end
+
+

  • T_ZERO = (2**32).coerce(0).first
  • T_ONE = (2**32).coerce(1).first
  • T_MONE = (2**32).coerce(-1).first
  • T31 = 2**31 # 2147483648
  • T31P = T31 - 1 # 2147483647
  • T32 = 2**32 # 4294967296
  • T32P = T32 - 1 # 4294967295
  • T64 = 2**64 # 18446744073709551616
  • T64P = T64 - 1 # 18446744073709551615
  • def test_big_2comp
  • assert_equal("-4294967296", (~T32P).to_s)
  • assert_equal("…f00000000", “%x” % -T32)
  • end
  • def test_int2inum
  • assert_equal([T31P], [T31P].pack(“I”).unpack(“I”))
  • assert_equal([T31P], [T31P].pack(“i”).unpack(“i”))
  • end
  • def test_quad_pack
  • assert_equal([ 1], [ 1].pack(“q”).unpack(“q”))
  • assert_equal([- 1], [- 1].pack(“q”).unpack(“q”))
  • assert_equal([ T31P], [ T31P].pack(“q”).unpack(“q”))
  • assert_equal([-T31P], [-T31P].pack(“q”).unpack(“q”))
  • assert_equal([ T64P], [ T64P].pack(“Q”).unpack(“Q”))
  • assert_equal([ 0], [ T64 ].pack(“Q”).unpack(“Q”))
  • end
  • def test_str_to_inum
  • assert_equal(1, " +1".to_i)
  • assert_equal(-1, " -1".to_i)
  • assert_equal(0, “++1”.to_i)
  • assert_equal(73, “111”.oct)
  • assert_equal(273, “0x111”.oct)
  • assert_equal(7, “0b111”.oct)
  • assert_equal(73, “0o111”.oct)
  • assert_equal(111, “0d111”.oct)
  • assert_equal(73, “0111”.oct)
  • assert_equal(111, Integer(“111”))
  • assert_equal(13, “111”.to_i(3))
  • assert_raise(ArgumentError) { “111”.to_i(37) }
  • assert_equal(1333, “111”.to_i(36))
  • assert_equal(1057, “111”.to_i(32))
  • assert_equal(0, “00a”.to_i)
  • assert_equal(1, Integer("1 "))
  • assert_raise(ArgumentError) { Integer(“1_”) }
  • assert_raise(ArgumentError) { Integer(“1__”) }
  • assert_raise(ArgumentError) { Integer(“1_0 x”) }
  • assert_equal(T31P, “1111111111111111111111111111111”.to_i(2))
  • end
  • def test_to_s2
  • assert_raise(ArgumentError) { T31P.to_s(37) }
  • assert_equal(32768, (10**32768-1).to_s.size)
  • assert_raise(RangeError) { Process.wait(1, T64P) }
  • assert_equal(“0”, T_ZERO.to_s)
  • assert_equal(“1”, T_ONE.to_s)
  • end
  • def test_to_f
  • assert_nothing_raised { T31P.to_f.to_i }
  • assert_raise(FloatDomainError) { (1024**1024).to_f.to_i }
  • end
  • def test_cmp
  • assert(T31P > 1)
  • assert(T31P < 2147483648.0)
  • assert(T31P < T64P)
  • assert(T64P > T31P)
  • assert_raise(ArgumentError) { T31P < “foo” }
  • end
  • def test_eq
  • assert(T31P != 1)
  • assert(T31P == 2147483647.0)
  • assert(T31P != “foo”)
  • end
  • def test_eql
  • assert(T31P.eql?(T31P))
  • end
  • def test_convert
  • assert_equal([255], [T_MONE].pack(“C”).unpack(“C”))
  • assert_equal([0], [T32].pack(“C”).unpack(“C”))
  • assert_raise(RangeError) { 0.to_s(T32) }
  • assert_raise(Errno::EINVAL) { Process.wait(0, T32P) }
  • assert_raise(RangeError) { Process.wait(0, T32) }
  • assert_raise(RangeError) { Process.wait(0, -T32P) }
  • end
  • def test_sub
  • assert_equal(-T31, T32 - (T32 + T31))
  • end
  • def test_plus
  • assert_equal(T64 + T32, T32 + T64)
  • assert_equal(T32.to_f, T32P + 1.0)
  • assert_raise(TypeError) { T32 + “foo” }
  • end
  • def test_minus
  • assert_equal(T32P.to_f, T32 - 1.0)
  • assert_raise(TypeError) { T32 - “foo” }
  • end
  • def test_mul
  • assert_equal(T32.to_f, T32 * 1.0)
  • assert_raise(TypeError) { T32 * “foo” }
  • end
  • def test_divrem
  • assert_equal(0, T32 / T64)
  • end
  • def test_div
  • assert_equal(T32.to_f, T32 / 1.0)
  • assert_raise(TypeError) { T32 / “foo” }
  • end
  • def test_modulo
  • assert_raise(TypeError) { T32 % “foo” }
  • end
  • def test_remainder
  • assert_equal(0, T32.remainder(1))
  • assert_raise(TypeError) { T32.remainder(“foo”) }
  • end
  • def test_divmod
  • assert_equal([T32, 0], T32.divmod(1))
  • assert_equal([2, 0], T32.divmod(T31))
  • assert_raise(TypeError) { T32.divmod(“foo”) }
  • end
  • def test_quo
  • assert_equal(T32.to_f, T32.quo(1))
  • assert_equal(T32.to_f, T32.quo(1.0))
  • assert_equal(T32.to_f, T32.quo(T_ONE))
  • assert_raise(TypeError) { T32.quo(“foo”) }
  • assert_equal(10241024, (10241024).quo(1))
  • assert_equal(10241024, (10241024).quo(1.0))
  • assert_equal(10241024*2, (10241024*2).quo(1))
  • inf = 1 / 0.0; nan = inf / inf
  • assert_raise(FloatDomainError) { (1024**1024*2).quo(nan) }
  • end
  • def test_pow
  • assert_equal(1.0, T32 ** 0.0)
  • assert_equal(1.0 / T32, T32 ** -1)
  • assert((T32 ** T32).infinite?)
  • assert((T32 ** (2**30-1)).infinite?)
  • assert_raise(TypeError) { T32**“foo” }
  • end
  • def test_and
  • assert_equal(0, T32 & 1)
  • assert_equal(-T32, (-T32) & (-T31))
  • assert_equal(0, T32 & T64)
  • end
  • def test_or
  • assert_equal(T32 + 1, T32 | 1)
  • assert_equal(T32 + T31, T32 | T31)
  • assert_equal(-T31, (-T32) | (-T31))
  • assert_equal(T64 + T32, T32 | T64)
  • end
  • def test_xor
  • assert_equal(T32 + 1, T32 ^ 1)
  • assert_equal(T32 + T31, T32 ^ T31)
  • assert_equal(T31, (-T32) ^ (-T31))
  • assert_equal(T64 + T32, T32 ^ T64)
  • end
  • def test_shift2
  • assert_equal(233, (232) << 1)
  • assert_equal(231, (232) << -1)
  • assert_equal(233, (232) << 1.0)
  • assert_equal(231, (232) << -1.0)
  • assert_equal(233, (232) << T_ONE)
  • assert_equal(231, (232) << T_MONE)
  • assert_equal(231, (232) >> 1)
  • assert_equal(233, (232) >> -1)
  • assert_equal(231, (232) >> 1.0)
  • assert_equal(233, (232) >> -1.0)
  • assert_equal(231, (232) >> T_ONE)
  • assert_equal(233, (232) >> T_MONE)
  • assert_equal( 0, (232) >> (232))
  • assert_equal(-1, -(232) >> (232))
  • assert_equal( 0, (2**32) >> 128)
  • assert_equal(-1, -(2**32) >> 128)
  • assert_equal( 0, (2**31) >> 32)
  • assert_equal(-1, -(2**31) >> 32)
  • end
  • def test_aref
  • assert_equal(0, (2**32)[0])
  • assert_equal(0, (232)[232])
  • assert_equal(0, (232)[-(232)])
  • assert_equal(0, (2**32)[T_ZERO])
  • assert_equal(0, (-(2**64))[0])
  • assert_equal(1, (-2**256)[256])
  • end
  • def test_hash
  • assert_nothing_raised { T31P.hash }
  • end
  • def test_coerce
  • assert_equal([T64P, T31P], T31P.coerce(T64P))
  • assert_raise(TypeError) { T31P.coerce(nil) }
  • end
  • def test_abs
  • assert_equal(T31P, (-T31P).abs)
  • end
  • def test_size
  • assert(T31P.size.is_a?(Integer))
  • end
  • def test_odd
  • assert_equal(true, (2**32+1).odd?)
  • assert_equal(false, (2**32).odd?)
  • end
  • def test_even
  • assert_equal(false, (2**32+1).even?)
  • assert_equal(true, (2**32).even?)
  • end
  • def interrupt
  • time = Time.now
  • start_flag = false
  • end_flag = false
  • thread = Thread.new do
  •  start_flag = true
    
  •  yield
    
  •  end_flag = true
    
  • end
  • sleep 1
  • thread.raise
  • thread.join rescue nil
  • start_flag && !end_flag && Time.now - time < 10
  • end
  • def test_interrupt
  • assert(interrupt { (65536 ** 65536).to_s })
  • end
    end

e$B$^$D$b$He(B e$B$f$-$R$m$G$9e(B

In message “Re: [ruby-dev:33258] exhaustive test for bignum.c”
on Mon, 21 Jan 2008 22:56:26 +0900, “Yusuke ENDOH” [email protected]
writes:

|test_bignum.rb e$B$K%F%9%[email protected]$r>e$2$F$_$^$7$?!#e(B
|gcov e$B$G$Ne(B bignum.c e$B$N%+%P%l%C%8$,e(B 50% e$B$+$ie(B 90% e$B$K$J$j$^$9!#e(B
|e$B$I$&$G$7$g$&$+!#e(B

e$B%3%_%C%H$7$F$/[email protected]$5$$!#e(B

In article
[email protected],
“Yusuke ENDOH” [email protected] writes:

test_bignum.rb e$B$K%F%9%[email protected]$r>e$2$F$_$^$7$?!#e(B
gcov e$B$G$Ne(B bignum.c e$B$N%+%P%l%C%8$,e(B 50% e$B$+$ie(B 90% e$B$K$J$j$^$9!#e(B
e$B$I$&$G$7$g$&$+!#e(B

rational e$B$re(B require
e$B$7$?>[email protected]$H%F%9%H$,$U$?$D<:GT$9$k$h$&$G!"e(B
test-all e$B$G$N<:GT$,A}$($F$$$^$9!#e(B
http://www.rubyist.net/~akr/chkbuild/debian-sarge/ruby-trunk/log/20080122T030900.diff.txt.gz

e$B$^$!!"e(Brational e$B$,0-$$$h$&$J5$$,$7$^$9$,!#e(B

% ./ruby -rrational test/ruby/test_bignum.rb
Loaded suite test/ruby/test_bignum
Started
…/home/akr/ruby/yarvo0/lib/ruby/1.9.0/rational.rb:517:
warning: in ab, b may be too big
/home/akr/ruby/yarvo0/lib/ruby/1.9.0/rational.rb:517: warning: in a
b,
b may be too big
F.F…test/ruby/test_bignum.rb:162: warning: Bignum out of Float
range

Finished in 2.752199378 seconds.

  1. Failure:
    test_pow(TestBignum) [test/ruby/test_bignum.rb:252]:
    exception expected but was
    Class:
    Message: <“comparison of String with 0 failed”>
    —Backtrace—
    /home/akr/ruby/yarvo0/lib/ruby/1.9.0/rational.rb:516:in >=' /home/akr/ruby/yarvo0/lib/ruby/1.9.0/rational.rb:516:inrpower’
    test/ruby/test_bignum.rb:252:in block in test_pow' test/ruby/test_bignum.rb:252:intest_pow’

  1. Failure:
    test_quo(TestBignum) [test/ruby/test_bignum.rb:239]:
    exception expected but was
    Class:
    Message: <"undefined method coerce' for \"foo\":String"> ---Backtrace--- /home/akr/ruby/yarvo0/lib/ruby/1.9.0/rational.rb:204:in/’
    /home/akr/ruby/yarvo0/lib/ruby/1.9.0/rational.rb:510:in quo' test/ruby/test_bignum.rb:239:inblock in test_quo’
    test/ruby/test_bignum.rb:239:in `test_quo’

37 tests, 294 assertions, 2 failures, 0 errors

e$B1sF#$G$9!#e(B

08/01/22 e$B$Ke(B Tanaka A.[email protected] e$B$5$s$O=q$-$^$7$?e(B:

rational e$B$re(B require e$B$7$?>[email protected]$H%F%9%H$,$U$?$D<:GT$9$k$h$&$G!"e(B
test-all e$B$G$N<:GT$,A}$($F$$$^$9!#e(B
http://www.rubyist.net/~akr/chkbuild/debian-sarge/ruby-trunk/log/20080122T030900.diff.txt.gz

make test-all e$B$G3NG’$7$F$^$;$s$G$7$?!#$9$_$^$;$s!#e(B
e$B1~5^=hCV$G$9$,!"LdBj$H$J$C$F$$$k%F%9%[email protected]$14K$a$F$*$-$^$7$?!#e(B

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs