gmp 0.1.7

data/test/tc_cmp.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class TC_Cmp < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(180)
+    @c=GMP::Q.new(2000,11) # ~181.82
+    @d=GMP::Q.new(3000,17) # ~176.47
+    @e=700
+    @f=2**32
+    @g=GMP::Q(360,2)
+  end
+
+  def test_cmp_q_q
+    assert_equal(@c >  @d, true,  "GMP::Q should compare correctly")
+    assert_equal(@c >= @d, true,  "GMP::Q should compare correctly")
+    assert_equal(@c <  @d, false, "GMP::Q should compare correctly")
+    assert_equal(@c <= @d, false, "GMP::Q should compare correctly")
+    assert_equal(@c == @d, false, "GMP::Q should == correctly")
+    assert_equal(@c == @c, true,  "GMP::Q should == correctly")
+    assert_equal(@c != @d, true,  "GMP::Q should != correctly")
+    assert_equal(@c != @c, false, "GMP::Q should != correctly")
+
+    assert_equal(@c <=> @d,  1, "GMP::Q should <=> correctly")
+    assert_equal(@c <=> @c,  0, "GMP::Q should <=> correctly")
+    assert_equal(@d <=> @c, -1, "GMP::Q should <=> correctly")
+  end
+
+  def test_cmp_q_z
+    assert_equal(@c >  @a, true,  "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c >= @a, true,  "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c <  @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c <= @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c == @a, false, "GMP::Q should == correctly with GMP::Z")
+    assert_equal(@c != @a, true,  "GMP::Q should != correctly with GMP::Z")
+
+    assert_equal(@a <  @c, true,  "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a <= @c, true,  "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >  @c, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >= @c, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a == @c, false, "GMP::Z should == correctly with GMP::Q")
+    assert_equal(@a != @c, true,  "GMP::Z should != correctly with GMP::Q")
+
+    assert_equal(@g == @a, true,  "GMP::Q should == correctly with GMP::Z")
+    assert_equal(@g != @a, false, "GMP::Q should != correctly with GMP::Z")
+
+    assert_equal(@d >  @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@d >= @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@d <  @a, true,  "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@d <= @a, true,  "GMP::Q should compare correctly with GMP::Z")
+
+    assert_equal(@a <  @d, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a <= @d, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >  @d, true,  "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >= @d, true,  "GMP::Z should compare correctly with GMP::Q")
+
+    assert_equal(@c <=> @a,  1, "GMP::Q should <=> correctly with GMP::Z")
+    assert_equal(@g <=> @a,  0, "GMP::Q should <=> correctly with GMP::Z")
+    assert_equal(@a <=> @c, -1, "GMP::Q should <=> correctly with GMP::Z")
+  end
+
+  def test_cmp_z_int
+    assert_equal(@a <=> @e, -1, "GMP::Z should <=> correctly with Fixnum")
+    assert_equal(@e <=> @a,  1, "Fixnum should <=> correctly with GMP::Z")
+    assert_equal(@a <=> @f, -1, "GMP::Z should <=> correctly with Bignum")
+    assert_equal(@f <=> @a,  1, "Bignum should <=> correctly with GMP::Z")
+  end
+
+  def test_cmp_q_int
+    assert_equal(@c <=> @e, -1, "GMP::Q should <=> correctly with Fixnum")
+    assert_equal(@e <=> @c,  1, "Fixnum should <=> correctly with GMP::Q")
+    assert_equal(@c <=> @f, -1, "GMP::Q should <=> correctly with Bignum")
+    assert_equal(@f <=> @c,  1, "Bignum should <=> correctly with GMP::Q")
+  end
+end

data/test/tc_fib_fac_nextprime.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class TC_fib_fac_nextprime < Test::Unit::TestCase
+  def setup
+    @z10 = GMP::Z.new(10)
+     @z7 = GMP::Z.new( 7)
+     @z8 = GMP::Z.new( 8)
+    @z11 = GMP::Z.new(11)
+    @z13 = GMP::Z.new(13)
+    @z17 = GMP::Z.new(17)
+    @z19 = GMP::Z.new(19)
+  end
+  
+  def test_fib
+    assert_equal(  1, GMP::Z.fib(   1), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  1, GMP::Z.fib(   2), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  2, GMP::Z.fib(   3), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  3, GMP::Z.fib(   4), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  5, GMP::Z.fib(   5), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  8, GMP::Z.fib(   6), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 13, GMP::Z.fib(   7), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 21, GMP::Z.fib(   8), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 34, GMP::Z.fib(   9), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 55, GMP::Z.fib(  10), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 55, GMP::Z.fib(@z10), "GMP::Z::fib(x : GMP::Z) should be calculated correctly.")
+    assert_equal( 89, GMP::Z.fib(  11), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(144, GMP::Z.fib(  12), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(233, GMP::Z.fib(  13), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(377, GMP::Z.fib(  14), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+  end
+  
+  def test_fac
+    assert_equal(   1, GMP::Z.fac( 0), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(   1, GMP::Z.fac( 1), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(   2, GMP::Z.fac( 2), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(   6, GMP::Z.fac( 3), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(  24, GMP::Z.fac( 4), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal( 120, GMP::Z.fac( 5), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal( 720, GMP::Z.fac( 6), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(5040, GMP::Z.fac( 7), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+  end
+
+  def test_nextprime
+    assert_equal(@z11,  @z7.nextprime, "GMP::Z.nextprime should work.")
+    assert_equal(@z11,  @z8.nextprime, "GMP::Z.nextprime should work.")
+    assert_equal(@z11,  @z8.nextprime, "GMP::Z.nextprime should work.")
+    assert_equal(@z13, @z11.nextprime, "GMP::Z.nextprime should work.")
+    assert_equal(@z17, @z13.nextprime, "GMP::Z.nextprime should work.")
+    assert_equal(@z19, @z17.nextprime, "GMP::Z.nextprime should work.")
+  end
+end

data/test/tc_floor_ceil_truncate.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class TC_floor_ceil_truncate < Test::Unit::TestCase
+  def setup
+    @a = GMP::Q.new(200,11)
+    @b = -@a
+    @c = GMP::Q.new(70,10)
+  end
+  
+  def test_floor_ceil_truncate
+    assert_equal(@a.floor, 18, "GMP::Q should floor.")
+    assert_equal(@a.ceil, 19, "GMP::Q should ceil.")
+    assert_equal(@a.trunc, 18, "GMP::Q should truncate.")
+    assert_equal(@b.floor, -19, "GMP::Q (negative) should floor.")
+    assert_equal(@b.ceil, -18, "GMP::Q (negative) should ceil.")
+    assert_equal(@b.trunc, -18, "GMP::Q (negative) should truncate.")
+    assert_equal(@c.floor, 7, "GMP::Q (integer) should floor.")
+    assert_equal(@c.ceil, 7, "GMP::Q (integer) should ceil.")
+    assert_equal(@c.trunc, 7, "GMP::Q (integer) should truncate.")
+  end
+end

data/test/tc_logical_roots.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class TC_logical_roots < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(100)
+    @b = GMP::Z.new( 27)
+    @c = GMP::Z.new( 99)
+  end
+  
+  def test_parity
+    assert  @a.even?, "GMP::Z should even? correctly."
+    assert !@b.even?, "GMP::Z should even? correctly."
+    assert !@c.even?, "GMP::Z should even? correctly."
+    assert !@a.odd?,  "GMP::Z should odd? correctly."
+    assert  @b.odd?,  "GMP::Z should odd? correctly."
+    assert  @c.odd?,  "GMP::Z should odd? correctly."
+  end
+  
+  def test_square
+    assert  @a.square?, "GMP::Z should square? correctly."
+    assert !@b.square?, "GMP::Z should square? correctly."
+    assert !@c.square?, "GMP::Z should square? correctly."
+  end
+  
+  def test_power
+    assert  @a.power?, "GMP::Z should power? correctly."
+    assert  @b.power?, "GMP::Z should power? correctly."
+    assert !@c.power?, "GMP::Z should power? correctly."
+  end
+  
+  def sqrtrem
+    assert_equal([10,  0], @a.sqrtrem, "GMP::Z should sqrtrem correctly.")
+    assert_equal([ 5,  2], @b.sqrtrem, "GMP::Z should sqrtrem correctly.")
+    assert_equal([ 9, 18], @c.sqrtrem, "GMP::Z should sqrtrem correctly.")
+  end
+  
+  def sqrt
+    assert_equal(10, @a.sqrt, "GMP::Z should sqrt correctly.")
+    assert_equal( 5, @b.sqrt, "GMP::Z should sqrt correctly.")
+    assert_equal( 9, @c.sqrt, "GMP::Z should sqrt correctly.")
+  end
+  
+  def root
+    assert_equal(4, @a.root(3), "GMP::Z should root correctly.")
+    assert_equal(3, @b.root(3), "GMP::Z should root correctly.")
+    assert_equal(4, @c.root(3), "GMP::Z should root correctly.")
+  end
+end

data/test/tc_q.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class TC_Q < Test::Unit::TestCase
+  def test_init_null
+    assert_equal(GMP::Q.new(), 0, "GMP::Q.new() should initialize to 0")
+  end
+
+  def test_init_fixnum
+    assert_equal(GMP::Q.new(1), 1, "GMP::Q.new(x : Fixnum) should initialize to 0")
+  end
+
+  def test_init_fixnum2
+    assert_equal(GMP::Q.new(1, 2).to_s, "1/2", "GMP::Q.new(num : Fixnum, den : Fixnum) should initialize to num/den")
+    assert_equal(GMP::Q.new(1, 3).to_s, "1/3", "GMP::Q.new(num : Fixnum, den : Fixnum) should initialize to num/den")
+    assert_equal(GMP::Q.new(2, 4).to_s, "1/2", "GMP::Q.new(num : Fixnum, den : Fixnum) should initialize to num/den")
+  end
+
+  def test_init_string
+    assert_equal(GMP::Q.new("1/2").to_s, "1/2", "GMP::Q.new(x : String) should initialize to x")
+    assert_equal(GMP::Q.new("1/3").to_s, "1/3", "GMP::Q.new(x : String) should initialize to x")
+  end
+
+  def test_init_q
+    a = GMP::Q.new(1,2)
+    assert_equal(GMP::Q.new(a), a, "GMP::Q.new(x : Q) should initialize to x")
+  end
+end

data/test/tc_q_basic.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+# [Q op Q, Q op Z, Z op Q, Q op FixNum, Q op BigNum, FixNum op Q, BigNum op Q]
+class TC_Q_Basic < Test::Unit::TestCase
+  def setup
+    @a=GMP::Q.new(100,11)
+    @b=GMP::Q.new(200,17)
+    @c=GMP::Z.new(40)
+    @d=2**32
+  end
+
+  def test_add
+    assert_equal(@a + @b, GMP::Q(3900, 187),       "GMP::Q should add GMP::Q correctly")
+    assert_equal(@a + @c, GMP::Q(540,  11),        "GMP::Q should add GMP::Z correctly")
+    assert_equal(@c + @a, GMP::Q(540,  11),        "GMP::Z should add GMP::Q correctly")
+    assert_equal(@a +  2, GMP::Q(122,  11),        "GMP::Z should add Fixnum correctly")
+    assert_equal(@a + @d, GMP::Q(47244640356, 11), "GMP::Z should add Bignum correctly")
+    assert_equal( 2 + @a, GMP::Q(122,  11),        "Fixnum should add GMP::Q correctly")
+    assert_equal(@d + @a, GMP::Q(47244640356, 11), "Bignum should add GMP::Q correctly")
+  end
+
+  def test_sub
+    assert_equal(@a - @b, GMP::Q(-500, 187),       "GMP::Q should subtract GMP::Q correctly")
+    assert_equal(@a - @c, GMP::Q(-340, 11),        "GMP::Q should subtract GMP::Z correctly")
+    assert_equal(@c - @a, GMP::Q(340,  11),        "GMP::Z should subtract GMP::Q correctly")
+    assert_equal(@a -  2, GMP::Q(78,  11),         "GMP::Z should subtract Fixnum correctly")
+    assert_equal(@a - @d, GMP::Q(-47244640156, 11),"GMP::Z should subtract Bignum correctly")
+    assert_equal( 2 - @a, GMP::Q(-78,  11),        "Fixnum should subtract GMP::Q correctly")
+    assert_equal(@d - @a, GMP::Q(47244640156, 11), "Bignum should subtract GMP::Q correctly")
+  end
+
+  def test_mul
+    assert_equal(@a * @b, GMP::Q(20000, 187),      "GMP::Q should multiply GMP::Q correctly")
+    assert_equal(@a * @c, GMP::Q(4000,  11),       "GMP::Q should multiply GMP::Z correctly")
+    assert_equal(@c * @a, GMP::Q(4000,  11),       "GMP::Z should multiply GMP::Q correctly")
+    assert_equal(@a *  2, GMP::Q(200,  11),        "GMP::Z should multiply Fixnum correctly")
+    # assert_equal(@a * @d, GMP::Q(429496729600, 11),"GMP::Z should multiply Bignum correctly")  # SEGFAULT
+    assert_equal( 2 * @a, GMP::Q(200,  11),        "Fixnum should multiply GMP::Q correctly")
+    # assert_equal(@d * @a, GMP::Q(429496729600, 11),"Bignum should multiply GMP::Q correctly")  # SEGFAULT
+  end
+end

data/test/tc_sgn_neg_abs.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class TC_sgn_neg_abs < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(10)
+    @b=GMP::Z.new()
+    @c=GMP::Z.new(-10)
+    @d=GMP::Q.new(10)
+    @e=GMP::Q.new()
+    @f=GMP::Q.new(-10)
+    @k=GMP::Z.new(10)
+    @l=GMP::Z.new()
+    @m=GMP::Z.new(-10)
+    @n=GMP::Q.new(10)
+    @o=GMP::Q.new()
+    @p=GMP::Q.new(-10)
+  end
+  
+  def test_sgn
+    assert_equal([1, 0, 1, 0], [@a.sgn, @b.sgn, @d.sgn, @e.sgn], "GMP::Z, GMP::Q should calculate sgn correctly")
+    assert_equal([-1, -1],     [@c.sgn, @f.sgn],                 "GMP::Z, GMP::Q should calculate sgn correctly")
+  end
+  
+  def test_neg
+    assert_equal(-@a, @c,                                        "-(x : GMP::Z) should be calculated correctly.")
+    assert_equal(-@c, @a,                                        "-(x : GMP::Z) should be calculated correctly.")
+    assert_equal(-@b, @b,                                        "-GMP::Z.new() should equal GMP::Z.new().")
+    assert_equal(-@d, @f,                                        "-(x : GMP::Q) should be calculated correctly.")
+    assert_equal(-@f, @d,                                        "-(x : GMP::Q) should be calculated correctly.")
+    assert_equal(-@e, @e,                                        "-GMP::Q.new() should equal GMP::Q.new().")
+    @k.neg!; @l.neg!; @m.neg!; @n.neg!; @o.neg!; @p.neg!
+    assert_equal(@k, @c,                                         "(x : GMP::Z).neg! should be calculated correctly.")
+    assert_equal(@l, @b,                                         "(x : GMP::Z).neg! should be calculated correctly.")
+    assert_equal(@m, @a,                                         "GMP::Z.new().neg! should equal GMP::Z.new().")
+    assert_equal(@n, @f,                                         "(x : GMP::Q).neg! should be calculated correctly.")
+    assert_equal(@o, @e,                                         "(x : GMP::Q).neg! should be calculated correctly.")
+    assert_equal(@p, @d,                                         "GMP::Q.new().neg! should equal GMP::Q.new().")
+  end
+  
+  def test_abs
+    assert_equal([10, 0, 10], [@a.abs, @b.abs, @c.abs],          "(x : GMP::Z).abs should be calculated correctly.")
+    assert_equal([10, 0, 10], [@d.abs, @e.abs, @f.abs],          "(x : GMP::Q).abs should be calculated correctly.")
+    @a.abs!; @b.abs!; @c.abs!; @d.abs!; @e.abs!; @f.abs!
+    assert_equal([10, 0, 10], [@a, @b, @c],                      "(x : GMP::Z).abs! should be calculated correctly.")
+    assert_equal([10, 0, 10], [@d, @e, @f],                      "(x : GMP::Q).abs! should be calculated correctly.")
+  end
+end

data/test/tc_swap.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TC_swap < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(100)
+    @b=GMP::Z.new(200)
+    @c=GMP::Q.new(100,11)
+    @d=GMP::Q.new(200,17)
+  end
+  
+  def test_swap
+    @a.swap @b
+    @c.swap @d
+    assert_equal(@a, 200, "GMP::Z should swap with GMP::Z.")
+    assert_equal(@b, 100, "GMP::Z should swap with GMP::Z.")
+    assert_equal(@c, GMP::Q.new(200,17), "GMP::Z should swap with GMP::Z.")
+    assert_equal(@d, GMP::Q.new(100,11), "GMP::Z should swap with GMP::Z.")
+  end
+end

data/test/tc_z.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class TC_Z < Test::Unit::TestCase
+  def test_init_null
+    assert_equal(GMP::Z.new(), 0, "GMP::Z.new() should initialize to 0")
+  end
+
+  def test_init_fixnum
+    assert_equal(GMP::Z.new(1), 1, "GMP::Z.new(x : Fixnum) should initialize to x")
+  end
+
+  def test_init_z
+    b = GMP::Z.new(1)
+    assert_equal(GMP::Z.new(b), b, "GMP::Z.new(x : GMP::Z) should initialize to x")
+  end
+
+  def test_init_string
+    assert_equal(GMP::Z.new("1"), 1, "GMP::Z.new(x : String) should initialize to x")
+  end
+
+  def test_init_bignum
+    assert_equal(GMP::Z.new(2**32), 2**32, "GMP::Z.new(x : Bignum) should initialize to x")
+  end
+
+  def test_cmp_z
+    a = GMP::Z.new(2)
+    b = GMP::Z.new(1)
+    assert_equal(a >  b, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a >  a, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b >  a, false, "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a >= b, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a >= a, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b >= a, false, "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a <= b, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a <= a, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b <= a, true,  "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a <  b, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a <  a, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b <  a, true,  "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a == b, false, "GMP::Z should == correctly with GMP::Z")
+    assert_equal(a == a, true,  "GMP::Z should == correctly with GMP::Z")
+
+    assert_equal(a != b, true,  "GMP::Z should != correctly with GMP::Z")
+    assert_equal(a != a, false, "GMP::Z should != correctly with GMP::Z")
+
+    assert_equal(a <=> b,  1, "GMP::Z should <=> correctly with GMP::Z")
+    assert_equal(a <=> a,  0, "GMP::Z should <=> correctly with GMP::Z")
+    assert_equal(b <=> a, -1, "GMP::Z should <=> correctly with GMP::Z")
+  end
+
+  def test_to_s
+    assert_equal("1",          GMP::Z.new(1).to_s,          "Z(1).to_s should equal '1'")
+    assert_equal("-1",         GMP::Z.new(-1).to_s,         "Z(1).to_s should equal '-1'")
+    assert_equal("1234567890", GMP::Z.new(1234567890).to_s, "GMP::Z should to_s correctly.")
+    assert_equal("100000",     GMP::Z.new(32).to_s(   2),   "GMP::Z should to_s(   2) correctly.")
+    assert_equal("200",        GMP::Z.new(32).to_s(   4),   "GMP::Z should to_s(   4) correctly.")
+    assert_equal("40",         GMP::Z.new(32).to_s(   8),   "GMP::Z should to_s(   8) correctly.")
+    assert_equal("32",         GMP::Z.new(32).to_s(  10),   "GMP::Z should to_s(  10) correctly.")
+    assert_equal("20",         GMP::Z.new(32).to_s(  16),   "GMP::Z should to_s(  16) correctly.")
+    assert_equal("a",          GMP::Z.new(10).to_s(  16),   "GMP::Z should to_s(  16) correctly.")
+    assert_equal("A",          GMP::Z.new(10).to_s( -16),   "GMP::Z should to_s( -16) correctly.")
+    assert_equal("11111111",   GMP::Z.new(255).to_s(:bin),  "GMP::Z should to_s(:bin) correctly.")
+    assert_equal("377",        GMP::Z.new(255).to_s(:oct),  "GMP::Z should to_s(:oct) correctly.")
+    assert_equal("255",        GMP::Z.new(255).to_s(:dec),  "GMP::Z should to_s(:dec) correctly.")
+    assert_equal("ff",         GMP::Z.new(255).to_s(:hex),  "GMP::Z should to_s(:hex) correctly.")
+  end
+end

data/test/tc_z_basic.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+# Tested: [Z op Z, Z op FixNum, Z op BigNum, FixNum op Z, BigNum op Z]
+# Things are tested both ways because the implementation is asymetrical
+class TC_Z_Basic < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(100)
+    @b=GMP::Z.new(200)
+    @c=2**32
+  end
+
+  def test_add
+    assert_equal(@a + @b, 100   + 200,   "GMP::Z should add correctly")
+    assert_equal(@a + 2,  100   + 2,     "GMP::Z should add correctly")
+    assert_equal(@a + @c, 100   + 2**32, "GMP::Z should add correctly")
+    assert_equal( 2 + @a, 2     + 100,   "GMP::Z should add correctly")
+    assert_equal(@c + @a, 2**32 + 100,   "GMP::Z should add correctly")
+  end
+
+  def test_sub
+    assert_equal(@a - @b, 100   - 200,   "GMP::Z should subtract correctly")
+    assert_equal(@a - 2,  100   - 2,     "GMP::Z should subtract correctly")
+    assert_equal(@a - @c, 100   - 2**32, "GMP::Z should subtract correctly")
+    assert_equal( 2 - @a, 2     - 100,   "GMP::Z should subtract correctly")
+    assert_equal(@c - @a, 2**32 - 100,   "GMP::Z should subtract correctly")
+  end
+
+  def test_mul
+    assert_equal(@a * @b, 100   * 200,   "GMP::Z should multiply correctly")
+    assert_equal(@a * 2,  100   * 2,     "GMP::Z should multiply correctly")
+    assert_equal(@a * @c, 100   * 2**32, "GMP::Z should multiply correctly")
+    assert_equal( 2 * @a, 2     * 100,   "GMP::Z should multiply correctly")
+    assert_equal(@c * @a, 2**32 * 100,   "GMP::Z should multiply correctly")
+  end
+end