* test/ruby/test_*.rb: replace 'assert(a == b)' with assert_equal(a, b)'

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4512 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

24 files changed, 565 insertions, 563 deletions

diff --git a/test/ruby/test_alias.rb b/test/ruby/test_alias.rb
index 0e94e14608..840bde4f54 100644
--- a/test/ruby/test_alias.rb
+++ b/test/ruby/test_alias.rb
@@ -28,11 +28,11 @@ class TestAlias < Test::Unit::TestCase
 
   def test_alias
     x = Alias2.new
-    assert(x.bar == "foo")
-    assert(x.baz == "foo+foo")
+    assert_equal(x.bar, "foo")
+    assert_equal(x.baz, "foo+foo")
     
     # test_check for cache
-    assert(x.baz == "foo+foo")
+    assert_equal(x.baz, "foo+foo")
     
     x = Alias3.new
     assert(!x.foo)
diff --git a/test/ruby/test_array.rb b/test/ruby/test_array.rb
index bc2902f6ff..de82032221 100644
--- a/test/ruby/test_array.rb
+++ b/test/ruby/test_array.rb
@@ -4,20 +4,20 @@ $KCODE = 'none'
 
 class TestArray < Test::Unit::TestCase
   def test_array
-    assert([1, 2] + [3, 4] == [1, 2, 3, 4])
-    assert([1, 2] * 2 == [1, 2, 1, 2])
-    assert([1, 2] * ":" == "1:2")
+    assert_equal([1, 2] + [3, 4], [1, 2, 3, 4])
+    assert_equal([1, 2] * 2, [1, 2, 1, 2])
+    assert_equal([1, 2] * ":", "1:2")
     
-    assert([1, 2].hash == [1, 2].hash)
+    assert_equal([1, 2].hash, [1, 2].hash)
     
-    assert([1,2,3] & [2,3,4] == [2,3])
-    assert([1,2,3] | [2,3,4] == [1,2,3,4])
-    assert([1,2,3] - [2,3] == [1])
+    assert_equal([1,2,3] & [2,3,4], [2,3])
+    assert_equal([1,2,3] | [2,3,4], [1,2,3,4])
+    assert_equal([1,2,3] - [2,3], [1])
     
     $x = [0, 1, 2, 3, 4, 5]
-    assert($x[2] == 2)
-    assert($x[1..3] == [1, 2, 3])
-    assert($x[1,3] == [1, 2, 3])
+    assert_equal($x[2], 2)
+    assert_equal($x[1..3], [1, 2, 3])
+    assert_equal($x[1,3], [1, 2, 3])
     
     $x[0, 2] = 10
     assert($x[0] == 10 && $x[1] == 2)
@@ -30,20 +30,20 @@ class TestArray < Test::Unit::TestCase
   end
 
   def test_array_andor
-    assert(([1,2,3]&[2,4,6]) == [2])
-    assert(([1,2,3]|[2,4,6]) == [1,2,3,4,6])
+    assert_equal(([1,2,3]&[2,4,6]), [2])
+    assert_equal(([1,2,3]|[2,4,6]), [1,2,3,4,6])
   end
     
   def test_compact
     $x = [nil, 1, nil, nil, 5, nil, nil]
     $x.compact!
-    assert($x == [1, 5])
+    assert_equal($x, [1, 5])
   end
 
   def test_uniq
     $x = [1, 1, 4, 2, 5, 4, 5, 1, 2]
     $x.uniq!
-    assert($x == [1, 4, 2, 5])
+    assert_equal($x, [1, 4, 2, 5])
     
     # empty?
     assert(!$x.empty?)
@@ -54,50 +54,50 @@ class TestArray < Test::Unit::TestCase
   def test_sort
     $x = ["it", "came", "to", "pass", "that", "..."]
     $x = $x.sort.join(" ")
-    assert($x == "... came it pass that to")
+    assert_equal($x, "... came it pass that to")
     $x = [2,5,3,1,7]
     $x.sort!{|a,b| a<=>b}		# sort with condition
-    assert($x == [1,2,3,5,7])
+    assert_equal($x, [1,2,3,5,7])
     $x.sort!{|a,b| b-a}		# reverse sort
-    assert($x == [7,5,3,2,1])
+    assert_equal($x, [7,5,3,2,1])
   end
 
   def test_split
     $x = "The Boassert of Mormon"
-    assert($x.split(//).reverse!.join == $x.reverse)
-    assert($x.reverse == $x.reverse!)
-    assert("1 byte string".split(//).reverse.join(":") == "g:n:i:r:t:s: :e:t:y:b: :1")
+    assert_equal($x.split(//).reverse!.join, $x.reverse)
+    assert_equal($x.reverse, $x.reverse!)
+    assert_equal("1 byte string".split(//).reverse.join(":"), "g:n:i:r:t:s: :e:t:y:b: :1")
     $x = "a b c  d"
-    assert($x.split == ['a', 'b', 'c', 'd'])
-    assert($x.split(' ') == ['a', 'b', 'c', 'd'])
+    assert_equal($x.split, ['a', 'b', 'c', 'd'])
+    assert_equal($x.split(' '), ['a', 'b', 'c', 'd'])
   end
 
   def test_misc
     assert(defined? "a".chomp)
-    assert("abc".scan(/./) == ["a", "b", "c"])
-    assert("1a2b3c".scan(/(\d.)/) == [["1a"], ["2b"], ["3c"]])
+    assert_equal("abc".scan(/./), ["a", "b", "c"])
+    assert_equal("1a2b3c".scan(/(\d.)/), [["1a"], ["2b"], ["3c"]])
     # non-greedy match
-    assert("a=12;b=22".scan(/(.*?)=(\d*);?/) == [["a", "12"], ["b", "22"]])
+    assert_equal("a=12;b=22".scan(/(.*?)=(\d*);?/), [["a", "12"], ["b", "22"]])
     
     $x = [1]
-    assert(($x * 5).join(":") == '1:1:1:1:1')
-    assert(($x * 1).join(":") == '1')
-    assert(($x * 0).join(":") == '')
+    assert_equal(($x * 5).join(":"), '1:1:1:1:1')
+    assert_equal(($x * 1).join(":"), '1')
+    assert_equal(($x * 0).join(":"), '')
     
     *$x = *(1..7).to_a
-    assert($x.size == 7)
-    assert($x == [1, 2, 3, 4, 5, 6, 7])
+    assert_equal($x.size, 7)
+    assert_equal($x, [1, 2, 3, 4, 5, 6, 7])
     
     $x = [1,2,3]
     $x[1,0] = $x
-    assert($x == [1,1,2,3,2,3])
+    assert_equal($x, [1,1,2,3,2,3])
     
     $x = [1,2,3]
     $x[-1,0] = $x
-    assert($x == [1,2,1,2,3,3])
+    assert_equal($x, [1,2,1,2,3,3])
     
     $x = [1,2,3]
     $x.concat($x)
-    assert($x == [1,2,3,1,2,3])
+    assert_equal($x, [1,2,3,1,2,3])
   end
 end
diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb
index faaca4775d..9a3e3a1636 100644
--- a/test/ruby/test_assignment.rb
+++ b/test/ruby/test_assignment.rb
@@ -5,365 +5,365 @@ $KCODE = 'none'
 class TestAssignment < Test::Unit::TestCase
   def test_assign
     a=[]; a[0] ||= "bar";
-    assert(a[0] == "bar")
+    assert_equal(a[0], "bar")
     h={}; h["foo"] ||= "bar";
-    assert(h["foo"] == "bar")
+    assert_equal(h["foo"], "bar")
     
     aa = 5
     aa ||= 25
-    assert(aa == 5)
+    assert_equal(aa, 5)
     bb ||= 25
-    assert(bb == 25)
+    assert_equal(bb, 25)
     cc &&=33
-    assert(cc == nil)
+    assert_equal(cc, nil)
     cc = 5
     cc &&=44
-    assert(cc == 44)
-    
-    a = nil; assert(a == nil)
-    a = 1; assert(a == 1)
-    a = []; assert(a == [])
-    a = [1]; assert(a == [1])
-    a = [nil]; assert(a == [nil])
-    a = [[]]; assert(a == [[]])
-    a = [1,2]; assert(a == [1,2])
-    a = [*[]]; assert(a == [])
-    a = [*[1]]; assert(a == [1])
-    a = [*[1,2]]; assert(a == [1,2])
-    
-    a = *nil; assert(a == nil)
-    a = *1; assert(a == 1)
-    a = *[]; assert(a == nil)
-    a = *[1]; assert(a == 1)
-    a = *[nil]; assert(a == nil)
-    a = *[[]]; assert(a == [])
-    a = *[1,2]; assert(a == [1,2])
-    a = *[*[]]; assert(a == nil)
-    a = *[*[1]]; assert(a == 1)
-    a = *[*[1,2]]; assert(a == [1,2])
-    
-    *a = nil; assert(a == [nil])
-    *a = 1; assert(a == [1])
-    *a = []; assert(a == [[]])
-    *a = [1]; assert(a == [[1]])
-    *a = [nil]; assert(a == [[nil]])
-    *a = [[]]; assert(a == [[[]]])
-    *a = [1,2]; assert(a == [[1,2]])
-    *a = [*[]]; assert(a == [[]])
-    *a = [*[1]]; assert(a == [[1]])
-    *a = [*[1,2]]; assert(a == [[1,2]])
-    
-    *a = *nil; assert(a == [nil])
-    *a = *1; assert(a == [1])
-    *a = *[]; assert(a == [])
-    *a = *[1]; assert(a == [1])
-    *a = *[nil]; assert(a == [nil])
-    *a = *[[]]; assert(a == [[]])
-    *a = *[1,2]; assert(a == [1,2])
-    *a = *[*[]]; assert(a == [])
-    *a = *[*[1]]; assert(a == [1])
-    *a = *[*[1,2]]; assert(a == [1,2])
-    
-    a,b,*c = nil; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = 1; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = []; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = [1]; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = [nil]; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = [[]]; assert([a,b,c] == [[],nil,[]])
-    a,b,*c = [1,2]; assert([a,b,c] == [1,2,[]])
-    a,b,*c = [*[]]; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = [*[1]]; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = [*[1,2]]; assert([a,b,c] == [1,2,[]])
-    
-    a,b,*c = *nil; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = *1; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = *[]; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = *[1]; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = *[nil]; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = *[[]]; assert([a,b,c] == [[],nil,[]])
-    a,b,*c = *[1,2]; assert([a,b,c] == [1,2,[]])
-    a,b,*c = *[*[]]; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = *[*[1]]; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = *[*[1,2]]; assert([a,b,c] == [1,2,[]])
+    assert_equal(cc, 44)
+    
+    a = nil; assert_equal(a, nil)
+    a = 1; assert_equal(a, 1)
+    a = []; assert_equal(a, [])
+    a = [1]; assert_equal(a, [1])
+    a = [nil]; assert_equal(a, [nil])
+    a = [[]]; assert_equal(a, [[]])
+    a = [1,2]; assert_equal(a, [1,2])
+    a = [*[]]; assert_equal(a, [])
+    a = [*[1]]; assert_equal(a, [1])
+    a = [*[1,2]]; assert_equal(a, [1,2])
+    
+    a = *nil; assert_equal(a, nil)
+    a = *1; assert_equal(a, 1)
+    a = *[]; assert_equal(a, nil)
+    a = *[1]; assert_equal(a, 1)
+    a = *[nil]; assert_equal(a, nil)
+    a = *[[]]; assert_equal(a, [])
+    a = *[1,2]; assert_equal(a, [1,2])
+    a = *[*[]]; assert_equal(a, nil)
+    a = *[*[1]]; assert_equal(a, 1)
+    a = *[*[1,2]]; assert_equal(a, [1,2])
+    
+    *a = nil; assert_equal(a, [nil])
+    *a = 1; assert_equal(a, [1])
+    *a = []; assert_equal(a, [[]])
+    *a = [1]; assert_equal(a, [[1]])
+    *a = [nil]; assert_equal(a, [[nil]])
+    *a = [[]]; assert_equal(a, [[[]]])
+    *a = [1,2]; assert_equal(a, [[1,2]])
+    *a = [*[]]; assert_equal(a, [[]])
+    *a = [*[1]]; assert_equal(a, [[1]])
+    *a = [*[1,2]]; assert_equal(a, [[1,2]])
+    
+    *a = *nil; assert_equal(a, [nil])
+    *a = *1; assert_equal(a, [1])
+    *a = *[]; assert_equal(a, [])
+    *a = *[1]; assert_equal(a, [1])
+    *a = *[nil]; assert_equal(a, [nil])
+    *a = *[[]]; assert_equal(a, [[]])
+    *a = *[1,2]; assert_equal(a, [1,2])
+    *a = *[*[]]; assert_equal(a, [])
+    *a = *[*[1]]; assert_equal(a, [1])
+    *a = *[*[1,2]]; assert_equal(a, [1,2])
+    
+    a,b,*c = nil; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = 1; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = []; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = [1]; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = [nil]; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = [[]]; assert_equal([a,b,c], [[],nil,[]])
+    a,b,*c = [1,2]; assert_equal([a,b,c], [1,2,[]])
+    a,b,*c = [*[]]; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = [*[1]]; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = [*[1,2]]; assert_equal([a,b,c], [1,2,[]])
+    
+    a,b,*c = *nil; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = *1; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = *[]; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = *[1]; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = *[nil]; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = *[[]]; assert_equal([a,b,c], [[],nil,[]])
+    a,b,*c = *[1,2]; assert_equal([a,b,c], [1,2,[]])
+    a,b,*c = *[*[]]; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = *[*[1]]; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = *[*[1,2]]; assert_equal([a,b,c], [1,2,[]])
   end
 
   def test_yield
-    def f; yield nil; end; f {|a| assert(a == nil)}
-    def f; yield 1; end; f {|a| assert(a == 1)}
-    def f; yield []; end; f {|a| assert(a == [])}
-    def f; yield [1]; end; f {|a| assert(a == [1])}
-    def f; yield [nil]; end; f {|a| assert(a == [nil])}
-    def f; yield [[]]; end; f {|a| assert(a == [[]])}
-    def f; yield [*[]]; end; f {|a| assert(a == [])}
-    def f; yield [*[1]]; end; f {|a| assert(a == [1])}
-    def f; yield [*[1,2]]; end; f {|a| assert(a == [1,2])}
-    
-    def f; yield *nil; end; f {|a| assert(a == nil)}
-    def f; yield *1; end; f {|a| assert(a == 1)}
-    def f; yield *[1]; end; f {|a| assert(a == 1)}
-    def f; yield *[nil]; end; f {|a| assert(a == nil)}
-    def f; yield *[[]]; end; f {|a| assert(a == [])}
-    def f; yield *[*[1]]; end; f {|a| assert(a == 1)}
-    
-    def f; yield; end; f {|*a| assert(a == [])}
-    def f; yield nil; end; f {|*a| assert(a == [nil])}
-    def f; yield 1; end; f {|*a| assert(a == [1])}
-    def f; yield []; end; f {|*a| assert(a == [[]])}
-    def f; yield [1]; end; f {|*a| assert(a == [[1]])}
-    def f; yield [nil]; end; f {|*a| assert(a == [[nil]])}
-    def f; yield [[]]; end; f {|*a| assert(a == [[[]]])}
-    def f; yield [1,2]; end; f {|*a| assert(a == [[1,2]])}
-    def f; yield [*[]]; end; f {|*a| assert(a == [[]])}
-    def f; yield [*[1]]; end; f {|*a| assert(a == [[1]])}
-    def f; yield [*[1,2]]; end; f {|*a| assert(a == [[1,2]])}
-    
-    def f; yield *nil; end; f {|*a| assert(a == [nil])}
-    def f; yield *1; end; f {|*a| assert(a == [1])}
-    def f; yield *[]; end; f {|*a| assert(a == [])}
-    def f; yield *[1]; end; f {|*a| assert(a == [1])}
-    def f; yield *[nil]; end; f {|*a| assert(a == [nil])}
-    def f; yield *[[]]; end; f {|*a| assert(a == [[]])}
-    def f; yield *[*[]]; end; f {|*a| assert(a == [])}
-    def f; yield *[*[1]]; end; f {|*a| assert(a == [1])}
-    def f; yield *[*[1,2]]; end; f {|*a| assert(a == [1,2])}
-    
-    def f; yield; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield nil; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield 1; end; f {|a,b,*c| assert([a,b,c] == [1,nil,[]])}
-    def f; yield []; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield [1]; end; f {|a,b,*c| assert([a,b,c] == [1,nil,[]])}
-    def f; yield [nil]; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield [[]]; end; f {|a,b,*c| assert([a,b,c] == [[],nil,[]])}
-    def f; yield [*[]]; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield [*[1]]; end; f {|a,b,*c| assert([a,b,c] == [1,nil,[]])}
-    def f; yield [*[1,2]]; end; f {|a,b,*c| assert([a,b,c] == [1,2,[]])}
-    
-    def f; yield *nil; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield *1; end; f {|a,b,*c| assert([a,b,c] == [1,nil,[]])}
-    def f; yield *[]; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield *[1]; end; f {|a,b,*c| assert([a,b,c] == [1,nil,[]])}
-    def f; yield *[nil]; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield *[[]]; end; f {|a,b,*c| assert([a,b,c] == [[],nil,[]])}
-    def f; yield *[*[]]; end; f {|a,b,*c| assert([a,b,c] == [nil,nil,[]])}
-    def f; yield *[*[1]]; end; f {|a,b,*c| assert([a,b,c] == [1,nil,[]])}
-    def f; yield *[*[1,2]]; end; f {|a,b,*c| assert([a,b,c] == [1,2,[]])}
+    def f; yield nil; end; f {|a| assert_equal(a, nil)}
+    def f; yield 1; end; f {|a| assert_equal(a, 1)}
+    def f; yield []; end; f {|a| assert_equal(a, [])}
+    def f; yield [1]; end; f {|a| assert_equal(a, [1])}
+    def f; yield [nil]; end; f {|a| assert_equal(a, [nil])}
+    def f; yield [[]]; end; f {|a| assert_equal(a, [[]])}
+    def f; yield [*[]]; end; f {|a| assert_equal(a, [])}
+    def f; yield [*[1]]; end; f {|a| assert_equal(a, [1])}
+    def f; yield [*[1,2]]; end; f {|a| assert_equal(a, [1,2])}
+    
+    def f; yield *nil; end; f {|a| assert_equal(a, nil)}
+    def f; yield *1; end; f {|a| assert_equal(a, 1)}
+    def f; yield *[1]; end; f {|a| assert_equal(a, 1)}
+    def f; yield *[nil]; end; f {|a| assert_equal(a, nil)}
+    def f; yield *[[]]; end; f {|a| assert_equal(a, [])}
+    def f; yield *[*[1]]; end; f {|a| assert_equal(a, 1)}
+    
+    def f; yield; end; f {|*a| assert_equal(a, [])}
+    def f; yield nil; end; f {|*a| assert_equal(a, [nil])}
+    def f; yield 1; end; f {|*a| assert_equal(a, [1])}
+    def f; yield []; end; f {|*a| assert_equal(a, [[]])}
+    def f; yield [1]; end; f {|*a| assert_equal(a, [[1]])}
+    def f; yield [nil]; end; f {|*a| assert_equal(a, [[nil]])}
+    def f; yield [[]]; end; f {|*a| assert_equal(a, [[[]]])}
+    def f; yield [1,2]; end; f {|*a| assert_equal(a, [[1,2]])}
+    def f; yield [*[]]; end; f {|*a| assert_equal(a, [[]])}
+    def f; yield [*[1]]; end; f {|*a| assert_equal(a, [[1]])}
+    def f; yield [*[1,2]]; end; f {|*a| assert_equal(a, [[1,2]])}
+    
+    def f; yield *nil; end; f {|*a| assert_equal(a, [nil])}
+    def f; yield *1; end; f {|*a| assert_equal(a, [1])}
+    def f; yield *[]; end; f {|*a| assert_equal(a, [])}
+    def f; yield *[1]; end; f {|*a| assert_equal(a, [1])}
+    def f; yield *[nil]; end; f {|*a| assert_equal(a, [nil])}
+    def f; yield *[[]]; end; f {|*a| assert_equal(a, [[]])}
+    def f; yield *[*[]]; end; f {|*a| assert_equal(a, [])}
+    def f; yield *[*[1]]; end; f {|*a| assert_equal(a, [1])}
+    def f; yield *[*[1,2]]; end; f {|*a| assert_equal(a, [1,2])}
+    
+    def f; yield; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield nil; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield 1; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
+    def f; yield []; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield [1]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
+    def f; yield [nil]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield [[]]; end; f {|a,b,*c| assert_equal([a,b,c], [[],nil,[]])}
+    def f; yield [*[]]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
+    def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,2,[]])}
+    
+    def f; yield *nil; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield *1; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
+    def f; yield *[]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield *[1]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
+    def f; yield *[nil]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield *[[]]; end; f {|a,b,*c| assert_equal([a,b,c], [[],nil,[]])}
+    def f; yield *[*[]]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
+    def f; yield *[*[1]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
+    def f; yield *[*[1,2]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,2,[]])}
   end
 
   def test_return
-    def r; return; end; a = r(); assert(a == nil)
-    def r; return nil; end; a = r(); assert(a == nil)
-    def r; return 1; end; a = r(); assert(a == 1)
-    def r; return []; end; a = r(); assert(a == [])
-    def r; return [1]; end; a = r(); assert(a == [1])
-    def r; return [nil]; end; a = r(); assert(a == [nil])
-    def r; return [[]]; end; a = r(); assert(a == [[]])
-    def r; return [*[]]; end; a = r(); assert(a == [])
-    def r; return [*[1]]; end; a = r(); assert(a == [1])
-    def r; return [*[1,2]]; end; a = r(); assert(a == [1,2])
-    
-    def r; return *nil; end; a = r(); assert(a == nil)
-    def r; return *1; end; a = r(); assert(a == 1)
-    def r; return *[]; end; a = r(); assert(a == nil)
-    def r; return *[1]; end; a = r(); assert(a == 1)
-    def r; return *[nil]; end; a = r(); assert(a == nil)
-    def r; return *[[]]; end; a = r(); assert(a == [])
-    def r; return *[*[]]; end; a = r(); assert(a == nil)
-    def r; return *[*[1]]; end; a = r(); assert(a == 1)
-    def r; return *[*[1,2]]; end; a = r(); assert(a == [1,2])
-    
-    def r; return *nil; end; a = *r(); assert(a == nil)
-    def r; return *1; end; a = *r(); assert(a == 1)
-    def r; return *[]; end; a = *r(); assert(a == nil)
-    def r; return *[1]; end; a = *r(); assert(a == 1)
-    def r; return *[nil]; end; a = *r(); assert(a == nil)
-    def r; return *[[]]; end; a = *r(); assert(a == nil)
-    def r; return *[*[]]; end; a = *r(); assert(a == nil)
-    def r; return *[*[1]]; end; a = *r(); assert(a == 1)
-    def r; return *[*[1,2]]; end; a = *r(); assert(a == [1,2])
-    
-    def r; return; end; *a = r(); assert(a == [nil])
-    def r; return nil; end; *a = r(); assert(a == [nil])
-    def r; return 1; end; *a = r(); assert(a == [1])
-    def r; return []; end; *a = r(); assert(a == [[]])
-    def r; return [1]; end; *a = r(); assert(a == [[1]])
-    def r; return [nil]; end; *a = r(); assert(a == [[nil]])
-    def r; return [[]]; end; *a = r(); assert(a == [[[]]])
-    def r; return [1,2]; end; *a = r(); assert(a == [[1,2]])
-    def r; return [*[]]; end; *a = r(); assert(a == [[]])
-    def r; return [*[1]]; end; *a = r(); assert(a == [[1]])
-    def r; return [*[1,2]]; end; *a = r(); assert(a == [[1,2]])
-    
-    def r; return *nil; end; *a = r(); assert(a == [nil])
-    def r; return *1; end; *a = r(); assert(a == [1])
-    def r; return *[]; end; *a = r(); assert(a == [nil])
-    def r; return *[1]; end; *a = r(); assert(a == [1])
-    def r; return *[nil]; end; *a = r(); assert(a == [nil])
-    def r; return *[[]]; end; *a = r(); assert(a == [[]])
-    def r; return *[1,2]; end; *a = r(); assert(a == [[1,2]])
-    def r; return *[*[]]; end; *a = r(); assert(a == [nil])
-    def r; return *[*[1]]; end; *a = r(); assert(a == [1])
-    def r; return *[*[1,2]]; end; *a = r(); assert(a == [[1,2]])
-    
-    def r; return *nil; end; *a = *r(); assert(a == [nil])
-    def r; return *1; end; *a = *r(); assert(a == [1])
-    def r; return *[]; end; *a = *r(); assert(a == [nil])
-    def r; return *[1]; end; *a = *r(); assert(a == [1])
-    def r; return *[nil]; end; *a = *r(); assert(a == [nil])
-    def r; return *[[]]; end; *a = *r(); assert(a == [])
-    def r; return *[1,2]; end; *a = *r(); assert(a == [1,2])
-    def r; return *[*[]]; end; *a = *r(); assert(a == [nil])
-    def r; return *[*[1]]; end; *a = *r(); assert(a == [1])
-    def r; return *[*[1,2]]; end; *a = *r(); assert(a == [1,2])
-    
-    def r; return; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return nil; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return 1; end; a,b,*c = r(); assert([a,b,c] == [1,nil,[]])
-    def r; return []; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return [1]; end; a,b,*c = r(); assert([a,b,c] == [1,nil,[]])
-    def r; return [nil]; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return [[]]; end; a,b,*c = r(); assert([a,b,c] == [[],nil,[]])
-    def r; return [1,2]; end; a,b,*c = r(); assert([a,b,c] == [1,2,[]])
-    def r; return [*[]]; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return [*[1]]; end; a,b,*c = r(); assert([a,b,c] == [1,nil,[]])
-    def r; return [*[1,2]]; end; a,b,*c = r(); assert([a,b,c] == [1,2,[]])
-    
-    def r; return *nil; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return *1; end; a,b,*c = r(); assert([a,b,c] == [1,nil,[]])
-    def r; return *[]; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return *[1]; end; a,b,*c = r(); assert([a,b,c] == [1,nil,[]])
-    def r; return *[nil]; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return *[[]]; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return *[1,2]; end; a,b,*c = r(); assert([a,b,c] == [1,2,[]])
-    def r; return *[*[]]; end; a,b,*c = r(); assert([a,b,c] == [nil,nil,[]])
-    def r; return *[*[1]]; end; a,b,*c = r(); assert([a,b,c] == [1,nil,[]])
-    def r; return *[*[1,2]]; end; a,b,*c = r(); assert([a,b,c] == [1,2,[]])
+    def r; return; end; a = r(); assert_equal(a, nil)
+    def r; return nil; end; a = r(); assert_equal(a, nil)
+    def r; return 1; end; a = r(); assert_equal(a, 1)
+    def r; return []; end; a = r(); assert_equal(a, [])
+    def r; return [1]; end; a = r(); assert_equal(a, [1])
+    def r; return [nil]; end; a = r(); assert_equal(a, [nil])
+    def r; return [[]]; end; a = r(); assert_equal(a, [[]])
+    def r; return [*[]]; end; a = r(); assert_equal(a, [])
+    def r; return [*[1]]; end; a = r(); assert_equal(a, [1])
+    def r; return [*[1,2]]; end; a = r(); assert_equal(a, [1,2])
+    
+    def r; return *nil; end; a = r(); assert_equal(a, nil)
+    def r; return *1; end; a = r(); assert_equal(a, 1)
+    def r; return *[]; end; a = r(); assert_equal(a, nil)
+    def r; return *[1]; end; a = r(); assert_equal(a, 1)
+    def r; return *[nil]; end; a = r(); assert_equal(a, nil)
+    def r; return *[[]]; end; a = r(); assert_equal(a, [])
+    def r; return *[*[]]; end; a = r(); assert_equal(a, nil)
+    def r; return *[*[1]]; end; a = r(); assert_equal(a, 1)
+    def r; return *[*[1,2]]; end; a = r(); assert_equal(a, [1,2])
+    
+    def r; return *nil; end; a = *r(); assert_equal(a, nil)
+    def r; return *1; end; a = *r(); assert_equal(a, 1)
+    def r; return *[]; end; a = *r(); assert_equal(a, nil)
+    def r; return *[1]; end; a = *r(); assert_equal(a, 1)
+    def r; return *[nil]; end; a = *r(); assert_equal(a, nil)
+    def r; return *[[]]; end; a = *r(); assert_equal(a, nil)
+    def r; return *[*[]]; end; a = *r(); assert_equal(a, nil)
+    def r; return *[*[1]]; end; a = *r(); assert_equal(a, 1)
+    def r; return *[*[1,2]]; end; a = *r(); assert_equal(a, [1,2])
+    
+    def r; return; end; *a = r(); assert_equal(a, [nil])
+    def r; return nil; end; *a = r(); assert_equal(a, [nil])
+    def r; return 1; end; *a = r(); assert_equal(a, [1])
+    def r; return []; end; *a = r(); assert_equal(a, [[]])
+    def r; return [1]; end; *a = r(); assert_equal(a, [[1]])
+    def r; return [nil]; end; *a = r(); assert_equal(a, [[nil]])
+    def r; return [[]]; end; *a = r(); assert_equal(a, [[[]]])
+    def r; return [1,2]; end; *a = r(); assert_equal(a, [[1,2]])
+    def r; return [*[]]; end; *a = r(); assert_equal(a, [[]])
+    def r; return [*[1]]; end; *a = r(); assert_equal(a, [[1]])
+    def r; return [*[1,2]]; end; *a = r(); assert_equal(a, [[1,2]])
+    
+    def r; return *nil; end; *a = r(); assert_equal(a, [nil])
+    def r; return *1; end; *a = r(); assert_equal(a, [1])
+    def r; return *[]; end; *a = r(); assert_equal(a, [nil])
+    def r; return *[1]; end; *a = r(); assert_equal(a, [1])
+    def r; return *[nil]; end; *a = r(); assert_equal(a, [nil])
+    def r; return *[[]]; end; *a = r(); assert_equal(a, [[]])
+    def r; return *[1,2]; end; *a = r(); assert_equal(a, [[1,2]])
+    def r; return *[*[]]; end; *a = r(); assert_equal(a, [nil])
+    def r; return *[*[1]]; end; *a = r(); assert_equal(a, [1])
+    def r; return *[*[1,2]]; end; *a = r(); assert_equal(a, [[1,2]])
+    
+    def r; return *nil; end; *a = *r(); assert_equal(a, [nil])
+    def r; return *1; end; *a = *r(); assert_equal(a, [1])
+    def r; return *[]; end; *a = *r(); assert_equal(a, [nil])
+    def r; return *[1]; end; *a = *r(); assert_equal(a, [1])
+    def r; return *[nil]; end; *a = *r(); assert_equal(a, [nil])
+    def r; return *[[]]; end; *a = *r(); assert_equal(a, [])
+    def r; return *[1,2]; end; *a = *r(); assert_equal(a, [1,2])
+    def r; return *[*[]]; end; *a = *r(); assert_equal(a, [nil])
+    def r; return *[*[1]]; end; *a = *r(); assert_equal(a, [1])
+    def r; return *[*[1,2]]; end; *a = *r(); assert_equal(a, [1,2])
+    
+    def r; return; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return nil; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return 1; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
+    def r; return []; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return [1]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
+    def r; return [nil]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return [[]]; end; a,b,*c = r(); assert_equal([a,b,c], [[],nil,[]])
+    def r; return [1,2]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
+    def r; return [*[]]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return [*[1]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
+    def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
+    
+    def r; return *nil; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return *1; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
+    def r; return *[]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return *[1]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
+    def r; return *[nil]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return *[[]]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return *[1,2]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
+    def r; return *[*[]]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
+    def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
+    def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
   end
 
   def test_lambda
-    f = lambda {|r,| assert([] == r)}
+    f = lambda {|r,| assert_equal([], r)}
     f.call([], *[])
     
-    f = lambda {|r,*l| assert([] == r); assert([1] == l)}
+    f = lambda {|r,*l| assert_equal([], r); assert_equal([1], l)}
     f.call([], *[1])
     
     f = lambda{|x| x}
-    assert(f.call(42) == 42)
-    assert(f.call([42]) == [42])
-    assert(f.call([[42]]) == [[42]])
-    assert(f.call([42,55]) == [42,55])
+    assert_equal(f.call(42), 42)
+    assert_equal(f.call([42]), [42])
+    assert_equal(f.call([[42]]), [[42]])
+    assert_equal(f.call([42,55]), [42,55])
     
     f = lambda{|x,| x}
-    assert(f.call(42) == 42)
-    assert(f.call([42]) == [42])
-    assert(f.call([[42]]) == [[42]])
-    assert(f.call([42,55]) == [42,55])
+    assert_equal(f.call(42), 42)
+    assert_equal(f.call([42]), [42])
+    assert_equal(f.call([[42]]), [[42]])
+    assert_equal(f.call([42,55]), [42,55])
     
     f = lambda{|*x| x}
-    assert(f.call(42) == [42])
-    assert(f.call([42]) == [[42]])
-    assert(f.call([[42]]) == [[[42]]])
-    assert(f.call([42,55]) == [[42,55]])
-    assert(f.call(42,55) == [42,55])
+    assert_equal(f.call(42), [42])
+    assert_equal(f.call([42]), [[42]])
+    assert_equal(f.call([[42]]), [[[42]]])
+    assert_equal(f.call([42,55]), [[42,55]])
+    assert_equal(f.call(42,55), [42,55])
   end
 
   def test_multi
     a,=*[1]
-    assert(a == 1)
+    assert_equal(a, 1)
     a,=*[[1]]
-    assert(a == [1])
+    assert_equal(a, [1])
     a,=*[[[1]]]
-    assert(a == [[1]])
+    assert_equal(a, [[1]])
     
     x, (y, z) = 1, 2, 3
-    assert([1,2,nil] == [x,y,z])
+    assert_equal([1,2,nil], [x,y,z])
     x, (y, z) = 1, [2,3]
-    assert([1,2,3] == [x,y,z])
+    assert_equal([1,2,3], [x,y,z])
     x, (y, z) = 1, [2]
-    assert([1,2,nil] == [x,y,z])
+    assert_equal([1,2,nil], [x,y,z])
   end
 
   def test_break
-    a = loop do break; end; assert(a == nil)
-    a = loop do break nil; end; assert(a == nil)
-    a = loop do break 1; end; assert(a == 1)
-    a = loop do break []; end; assert(a == [])
-    a = loop do break [1]; end; assert(a == [1])
-    a = loop do break [nil]; end; assert(a == [nil])
-    a = loop do break [[]]; end; assert(a == [[]])
-    a = loop do break [*[]]; end; assert(a == [])
-    a = loop do break [*[1]]; end; assert(a == [1])
-    a = loop do break [*[1,2]]; end; assert(a == [1,2])
-    
-    a = loop do break *nil; end; assert(a == nil)
-    a = loop do break *1; end; assert(a == 1)
-    a = loop do break *[]; end; assert(a == nil)
-    a = loop do break *[1]; end; assert(a == 1)
-    a = loop do break *[nil]; end; assert(a == nil)
-    a = loop do break *[[]]; end; assert(a == [])
-    a = loop do break *[*[]]; end; assert(a == nil)
-    a = loop do break *[*[1]]; end; assert(a == 1)
-    a = loop do break *[*[1,2]]; end; assert(a == [1,2])
-    
-    *a = loop do break; end; assert(a == [nil])
-    *a = loop do break nil; end; assert(a == [nil])
-    *a = loop do break 1; end; assert(a == [1])
-    *a = loop do break []; end; assert(a == [[]])
-    *a = loop do break [1]; end; assert(a == [[1]])
-    *a = loop do break [nil]; end; assert(a == [[nil]])
-    *a = loop do break [[]]; end; assert(a == [[[]]])
-    *a = loop do break [1,2]; end; assert(a == [[1,2]])
-    *a = loop do break [*[]]; end; assert(a == [[]])
-    *a = loop do break [*[1]]; end; assert(a == [[1]])
-    *a = loop do break [*[1,2]]; end; assert(a == [[1,2]])
-    
-    *a = loop do break *nil; end; assert(a == [nil])
-    *a = loop do break *1; end; assert(a == [1])
-    *a = loop do break *[]; end; assert(a == [nil])
-    *a = loop do break *[1]; end; assert(a == [1])
-    *a = loop do break *[nil]; end; assert(a == [nil])
-    *a = loop do break *[[]]; end; assert(a == [[]])
-    *a = loop do break *[1,2]; end; assert(a == [[1,2]])
-    *a = loop do break *[*[]]; end; assert(a == [nil])
-    *a = loop do break *[*[1]]; end; assert(a == [1])
-    *a = loop do break *[*[1,2]]; end; assert(a == [[1,2]])
-    
-    *a = *loop do break *nil; end; assert(a == [nil])
-    *a = *loop do break *1; end; assert(a == [1])
-    *a = *loop do break *[]; end; assert(a == [nil])
-    *a = *loop do break *[1]; end; assert(a == [1])
-    *a = *loop do break *[nil]; end; assert(a == [nil])
-    *a = *loop do break *[[]]; end; assert(a == [])
-    *a = *loop do break *[1,2]; end; assert(a == [1,2])
-    *a = *loop do break *[*[]]; end; assert(a == [nil])
-    *a = *loop do break *[*[1]]; end; assert(a == [1])
-    *a = *loop do break *[*[1,2]]; end; assert(a == [1,2])
-    
-    a,b,*c = loop do break; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break nil; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break 1; end; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = loop do break []; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break [1]; end; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = loop do break [nil]; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break [[]]; end; assert([a,b,c] == [[],nil,[]])
-    a,b,*c = loop do break [1,2]; end; assert([a,b,c] == [1,2,[]])
-    a,b,*c = loop do break [*[]]; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break [*[1]]; end; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = loop do break [*[1,2]]; end; assert([a,b,c] == [1,2,[]])
-    
-    a,b,*c = loop do break *nil; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break *1; end; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = loop do break *[]; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break *[1]; end; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = loop do break *[nil]; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break *[[]]; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break *[1,2]; end; assert([a,b,c] == [1,2,[]])
-    a,b,*c = loop do break *[*[]]; end; assert([a,b,c] == [nil,nil,[]])
-    a,b,*c = loop do break *[*[1]]; end; assert([a,b,c] == [1,nil,[]])
-    a,b,*c = loop do break *[*[1,2]]; end; assert([a,b,c] == [1,2,[]])
+    a = loop do break; end; assert_equal(a, nil)
+    a = loop do break nil; end; assert_equal(a, nil)
+    a = loop do break 1; end; assert_equal(a, 1)
+    a = loop do break []; end; assert_equal(a, [])
+    a = loop do break [1]; end; assert_equal(a, [1])
+    a = loop do break [nil]; end; assert_equal(a, [nil])
+    a = loop do break [[]]; end; assert_equal(a, [[]])
+    a = loop do break [*[]]; end; assert_equal(a, [])
+    a = loop do break [*[1]]; end; assert_equal(a, [1])
+    a = loop do break [*[1,2]]; end; assert_equal(a, [1,2])
+    
+    a = loop do break *nil; end; assert_equal(a, nil)
+    a = loop do break *1; end; assert_equal(a, 1)
+    a = loop do break *[]; end; assert_equal(a, nil)
+    a = loop do break *[1]; end; assert_equal(a, 1)
+    a = loop do break *[nil]; end; assert_equal(a, nil)
+    a = loop do break *[[]]; end; assert_equal(a, [])
+    a = loop do break *[*[]]; end; assert_equal(a, nil)
+    a = loop do break *[*[1]]; end; assert_equal(a, 1)
+    a = loop do break *[*[1,2]]; end; assert_equal(a, [1,2])
+    
+    *a = loop do break; end; assert_equal(a, [nil])
+    *a = loop do break nil; end; assert_equal(a, [nil])
+    *a = loop do break 1; end; assert_equal(a, [1])
+    *a = loop do break []; end; assert_equal(a, [[]])
+    *a = loop do break [1]; end; assert_equal(a, [[1]])
+    *a = loop do break [nil]; end; assert_equal(a, [[nil]])
+    *a = loop do break [[]]; end; assert_equal(a, [[[]]])
+    *a = loop do break [1,2]; end; assert_equal(a, [[1,2]])
+    *a = loop do break [*[]]; end; assert_equal(a, [[]])
+    *a = loop do break [*[1]]; end; assert_equal(a, [[1]])
+    *a = loop do break [*[1,2]]; end; assert_equal(a, [[1,2]])
+    
+    *a = loop do break *nil; end; assert_equal(a, [nil])
+    *a = loop do break *1; end; assert_equal(a, [1])
+    *a = loop do break *[]; end; assert_equal(a, [nil])
+    *a = loop do break *[1]; end; assert_equal(a, [1])
+    *a = loop do break *[nil]; end; assert_equal(a, [nil])
+    *a = loop do break *[[]]; end; assert_equal(a, [[]])
+    *a = loop do break *[1,2]; end; assert_equal(a, [[1,2]])
+    *a = loop do break *[*[]]; end; assert_equal(a, [nil])
+    *a = loop do break *[*[1]]; end; assert_equal(a, [1])
+    *a = loop do break *[*[1,2]]; end; assert_equal(a, [[1,2]])
+    
+    *a = *loop do break *nil; end; assert_equal(a, [nil])
+    *a = *loop do break *1; end; assert_equal(a, [1])
+    *a = *loop do break *[]; end; assert_equal(a, [nil])
+    *a = *loop do break *[1]; end; assert_equal(a, [1])
+    *a = *loop do break *[nil]; end; assert_equal(a, [nil])
+    *a = *loop do break *[[]]; end; assert_equal(a, [])
+    *a = *loop do break *[1,2]; end; assert_equal(a, [1,2])
+    *a = *loop do break *[*[]]; end; assert_equal(a, [nil])
+    *a = *loop do break *[*[1]]; end; assert_equal(a, [1])
+    *a = *loop do break *[*[1,2]]; end; assert_equal(a, [1,2])
+    
+    a,b,*c = loop do break; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break nil; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break 1; end; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = loop do break []; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break [1]; end; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = loop do break [nil]; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break [[]]; end; assert_equal([a,b,c], [[],nil,[]])
+    a,b,*c = loop do break [1,2]; end; assert_equal([a,b,c], [1,2,[]])
+    a,b,*c = loop do break [*[]]; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break [*[1]]; end; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = loop do break [*[1,2]]; end; assert_equal([a,b,c], [1,2,[]])
+    
+    a,b,*c = loop do break *nil; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break *1; end; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = loop do break *[]; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break *[1]; end; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = loop do break *[nil]; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break *[[]]; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break *[1,2]; end; assert_equal([a,b,c], [1,2,[]])
+    a,b,*c = loop do break *[*[]]; end; assert_equal([a,b,c], [nil,nil,[]])
+    a,b,*c = loop do break *[*[1]]; end; assert_equal([a,b,c], [1,nil,[]])
+    a,b,*c = loop do break *[*[1,2]]; end; assert_equal([a,b,c], [1,2,[]])
   end
 
   def test_next
-    def r(val); a = yield(); assert(a == val, 2); end
+    def r(val); a = yield(); assert_equal(a, val); end
     r(nil){next}
     r(nil){next nil}
     r(1){next 1}
@@ -385,7 +385,7 @@ class TestAssignment < Test::Unit::TestCase
     r(1){next *[*[1]]}
     r([1,2]){next *[*[1,2]]}
     
-    def r(val); *a = yield(); assert(a == val, 2); end
+    def r(val); *a = yield(); assert_equal(a, val); end
     r([nil]){next}
     r([nil]){next nil}
     r([1]){next 1}
@@ -398,7 +398,7 @@ class TestAssignment < Test::Unit::TestCase
     r([[1]]){next [*[1]]}
     r([[1,2]]){next [*[1,2]]}
     
-    def r(val); *a = *yield(); assert(a == val, 2); end
+    def r(val); *a = *yield(); assert_equal(a, val); end
     r([nil]){next *nil}
     r([1]){next *1}
     r([nil]){next *[]}
@@ -410,7 +410,7 @@ class TestAssignment < Test::Unit::TestCase
     r([1]){next *[*[1]]}
     r([1,2]){next *[*[1,2]]}
     
-    def r(val); a,b,*c = yield(); assert([a,b,c] == val, 2); end
+    def r(val); a,b,*c = yield(); assert_equal([a,b,c], val); end
     r([nil,nil,[]]){next}
     r([nil,nil,[]]){next nil}
     r([1,nil,[]]){next 1}
@@ -423,7 +423,7 @@ class TestAssignment < Test::Unit::TestCase
     r([1,nil,[]]){next [*[1]]}
     r([1,2,[]]){next [*[1,2]]}
     
-    def r(val); a,b,*c = *yield(); assert([a,b,c] == val, 2); end
+    def r(val); a,b,*c = *yield(); assert_equal([a,b,c], val); end
     r([nil,nil,[]]){next *nil}
     r([1,nil,[]]){next *1}
     r([nil,nil,[]]){next *[]}
@@ -439,7 +439,7 @@ class TestAssignment < Test::Unit::TestCase
   def test_assign2
     a = nil
     assert(defined?(a))
-    assert(a == nil)
+    assert_equal(a, nil)
     
     # multiple asignment
     a, b = 1, 2
@@ -449,7 +449,7 @@ class TestAssignment < Test::Unit::TestCase
     assert(a == 2 && b == 1)
     
     a, = 1,2
-    assert(a == 1)
+    assert_equal(a, 1)
     
     a, *b = 1, 2, 3
     assert(a == 1 && b == [2, 3])
@@ -458,12 +458,12 @@ class TestAssignment < Test::Unit::TestCase
     assert(a == 1 && b == 2 && c == 3 && d == 4)
     
     *a = 1, 2, 3
-    assert(a == [1, 2, 3])
+    assert_equal(a, [1, 2, 3])
     
     *a = 4
-    assert(a == [4])
+    assert_equal(a, [4])
     
     *a = nil
-    assert(a == [nil])
+    assert_equal(a, [nil])
   end
 end
diff --git a/test/ruby/test_bignum.rb b/test/ruby/test_bignum.rb
index c0cab6d11d..78e3a38279 100644
--- a/test/ruby/test_bignum.rb
+++ b/test/ruby/test_bignum.rb
@@ -15,18 +15,18 @@ class TestBignum < Test::Unit::TestCase
 
   def test_bignum
     $x = fact(40)
-    assert($x == $x)
-    assert($x == fact(40))
+    assert_equal($x, $x)
+    assert_equal($x, fact(40))
     assert($x < $x+2)
     assert($x > $x-2)
-    assert($x == 815915283247897734345611269596115894272000000000)
-    assert($x != 815915283247897734345611269596115894272000000001)
-    assert($x+1 == 815915283247897734345611269596115894272000000001)
-    assert($x/fact(20) == 335367096786357081410764800000)
+    assert_equal($x, 815915283247897734345611269596115894272000000000)
+    assert_not_equal($x, 815915283247897734345611269596115894272000000001)
+    assert_equal($x+1, 815915283247897734345611269596115894272000000001)
+    assert_equal($x/fact(20), 335367096786357081410764800000)
     $x = -$x
-    assert($x == -815915283247897734345611269596115894272000000000)
-    assert(2-(2**32) == -(2**32-2))
-    assert(2**32 - 5 == (2**32-3)-2)
+    assert_equal($x, -815915283247897734345611269596115894272000000000)
+    assert_equal(2-(2**32), -(2**32-2))
+    assert_equal(2**32 - 5, (2**32-3)-2)
 
     $good = true;
     for i in 1000..1014
@@ -65,33 +65,33 @@ class TestBignum < Test::Unit::TestCase
   def test_calc
     b = 10**80
     a = b * 9 + 7
-    assert(7 == a.modulo(b))
-    assert(-b + 7 == a.modulo(-b))
-    assert(b + -7 == (-a).modulo(b))
-    assert(-7 == (-a).modulo(-b))
-    assert(7 == a.remainder(b))
-    assert(7 == a.remainder(-b))
-    assert(-7 == (-a).remainder(b))
-    assert(-7 == (-a).remainder(-b))
+    assert_equal(7, a.modulo(b))
+    assert_equal(-b + 7, a.modulo(-b))
+    assert_equal(b + -7, (-a).modulo(b))
+    assert_equal(-7, (-a).modulo(-b))
+    assert_equal(7, a.remainder(b))
+    assert_equal(7, a.remainder(-b))
+    assert_equal(-7, (-a).remainder(b))
+    assert_equal(-7, (-a).remainder(-b))
     
-    assert(10**40+10**20 == 10000000000000000000100000000000000000000)
-    assert(10**40/10**20 == 100000000000000000000)
+    assert_equal(10**40+10**20, 10000000000000000000100000000000000000000)
+    assert_equal(10**40/10**20, 100000000000000000000)
     
     a = 677330545177305025495135714080
     b = 14269972710765292560
-    assert(a % b == 0)
-    assert(-a % b == 0)
+    assert_equal(a % b, 0)
+    assert_equal(-a % b, 0)
   end
 
   def test_shift
     def shift_test(a)
       b = a / (2 ** 32)
       c = a >> 32
-      assert(b == c)
+      assert_equal(b, c)
     
       b = a * (2 ** 32)
       c = a << 32
-      assert(b == c)
+      assert_equal(b, c)
     end
     
     shift_test(-4518325415524767873)
diff --git a/test/ruby/test_call.rb b/test/ruby/test_call.rb
index f47164b438..c92b8b0ae9 100644
--- a/test/ruby/test_call.rb
+++ b/test/ruby/test_call.rb
@@ -24,9 +24,9 @@ class TestCall < Test::Unit::TestCase
       assert(true)
     end
     
-    assert(aaa(1) == [1, 100])
-    assert(aaa(1, 2) == [1, 2])
-    assert(aaa(1, 2, 3, 4) == [1, 2, 3, 4])
-    assert(aaa(1, *[2, 3, 4]) == [1, 2, 3, 4])
+    assert_equal(aaa(1), [1, 100])
+    assert_equal(aaa(1, 2), [1, 2])
+    assert_equal(aaa(1, 2, 3, 4), [1, 2, 3, 4])
+    assert_equal(aaa(1, *[2, 3, 4]), [1, 2, 3, 4])
   end
 end
diff --git a/test/ruby/test_clone.rb b/test/ruby/test_clone.rb
index ad146709ad..64dba41c21 100644
--- a/test/ruby/test_clone.rb
+++ b/test/ruby/test_clone.rb
@@ -19,9 +19,9 @@ class TestClone < Test::Unit::TestCase
       "test2"
     end
     
-    assert(bar.test2 == "test2")
-    assert(bar.test == "test")
-    assert(foo.test == "test")  
+    assert_equal(bar.test2, "test2")
+    assert_equal(bar.test, "test")
+    assert_equal(foo.test, "test")  
     
     begin
       foo.test2
@@ -30,6 +30,6 @@ class TestClone < Test::Unit::TestCase
       assert true
     end
     
-    assert(M003.ancestors == [M003, M002, M001])
+    assert_equal(M003.ancestors, [M003, M002, M001])
   end
 end
diff --git a/test/ruby/test_const.rb b/test/ruby/test_const.rb
index 179271aef1..9ad5bd4338 100644
--- a/test/ruby/test_const.rb
+++ b/test/ruby/test_const.rb
@@ -20,16 +20,16 @@ class TestConst < Test::Unit::TestCase
     self.class.class_eval {
       include Const
     }
-    assert([TEST1,TEST2,TEST3,TEST4] == [1,2,3,4])
+    assert_equal([TEST1,TEST2,TEST3,TEST4], [1,2,3,4])
     
     self.class.class_eval {
       include Const2
     }
     STDERR.print "intentionally redefines TEST3, TEST4\n" if $VERBOSE
-    assert([TEST1,TEST2,TEST3,TEST4] == [1,2,6,8])
+    assert_equal([TEST1,TEST2,TEST3,TEST4], [1,2,6,8])
     
-    assert((String <=> Object) == -1)
-    assert((Object <=> String) == 1)
-    assert((Array <=> String) == nil)
+    assert_equal((String <=> Object), -1)
+    assert_equal((Object <=> String), 1)
+    assert_equal((Array <=> String), nil)
   end
 end
diff --git a/test/ruby/test_defined.rb b/test/ruby/test_defined.rb
index f53c69f791..999457f917 100644
--- a/test/ruby/test_defined.rb
+++ b/test/ruby/test_defined.rb
@@ -22,7 +22,7 @@ class TestDefined < Test::Unit::TestCase
     $x = nil
 
     assert(defined?($x))		# global variable
-    assert(defined?($x) == 'global-variable')# returns description
+    assert_equal(defined?($x), 'global-variable')# returns description
     
     foo=5
     assert(defined?(foo))		# local variable
@@ -33,7 +33,7 @@ class TestDefined < Test::Unit::TestCase
     assert(defined?(1 == 2))		# operator expression
     
     f = Foo.new
-    assert(defined?(f.foo) == nil)
+    assert_equal(defined?(f.foo), nil)
     f.bar(f) { |v| assert(v) }
     
     assert(defined_test)		# not iterator
diff --git a/test/ruby/test_eval.rb b/test/ruby/test_eval.rb
index 8de359b8dd..35cbbfd7d6 100644
--- a/test/ruby/test_eval.rb
+++ b/test/ruby/test_eval.rb
@@ -13,7 +13,7 @@ class TestEval < Test::Unit::TestCase
   end
 
   def test_eval
-    assert(eval("") == nil)
+    assert_equal(eval(""), nil)
     $bad=false
     eval 'while false; $bad = true; print "foo\n" end'
     assert(!$bad)
@@ -32,16 +32,16 @@ class TestEval < Test::Unit::TestCase
       assert(false)
     end
     
-    assert(eval("$foo") == 'assert(true)')
-    assert(eval("true") == true)
+    assert_equal(eval("$foo"), 'assert(true)')
+    assert_equal(eval("true"), true)
     i = 5
     assert(eval("i == 5"))
-    assert(eval("i") == 5)
+    assert_equal(eval("i"), 5)
     assert(eval("defined? i"))
     
     $x = test_ev
-    assert(eval("local1", $x) == "local1") # normal local var
-    assert(eval("local2", $x) == "local2") # nested local var
+    assert_equal(eval("local1", $x), "local1") # normal local var
+    assert_equal(eval("local2", $x), "local2") # nested local var
     $bad = true
     begin
       p eval("local1")
@@ -58,8 +58,8 @@ class TestEval < Test::Unit::TestCase
 	$x = binding
       end
     )
-    assert(eval("EVTEST1", $x) == 25)	# constant in module
-    assert(eval("evtest2", $x) == 125)	# local var in module
+    assert_equal(eval("EVTEST1", $x), 25)	# constant in module
+    assert_equal(eval("evtest2", $x), 125)	# local var in module
     $bad = true
     begin
       eval("EVTEST1")
@@ -70,25 +70,25 @@ class TestEval < Test::Unit::TestCase
     
     x = proc{}
     eval "i4 = 1", x
-    assert(eval("i4", x) == 1)
+    assert_equal(eval("i4", x), 1)
     x = proc{proc{}}.call
     eval "i4 = 22", x
-    assert(eval("i4", x) == 22)
+    assert_equal(eval("i4", x), 22)
     $x = []
     x = proc{proc{}}.call
     eval "(0..9).each{|i5| $x[i5] = proc{i5*2}}", x
-    assert($x[4].call == 8)
+    assert_equal($x[4].call, 8)
     
     x = binding
     eval "i = 1", x
-    assert(eval("i", x) == 1)
+    assert_equal(eval("i", x), 1)
     x = proc{binding}.call
     eval "i = 22", x
-    assert(eval("i", x) == 22)
+    assert_equal(eval("i", x), 22)
     $x = []
     x = proc{binding}.call
     eval "(0..9).each{|i5| $x[i5] = proc{i5*2}}", x
-    assert($x[4].call == 8)
+    assert_equal($x[4].call, 8)
     x = proc{binding}.call
     eval "for i6 in 1..1; j6=i6; end", x
     assert(eval("defined? i6", x))
@@ -100,25 +100,25 @@ class TestEval < Test::Unit::TestCase
       foo22 = 5
       proc{foo11=22}.call
       proc{foo22=55}.call
-      assert(eval("foo11", p) == eval("foo11"))
-      assert(eval("foo11") == 1)
-      assert(eval("foo22", p) == eval("foo22"))
-      assert(eval("foo22") == 55)
+      assert_equal(eval("foo11", p), eval("foo11"))
+      assert_equal(eval("foo11"), 1)
+      assert_equal(eval("foo22", p), eval("foo22"))
+      assert_equal(eval("foo22"), 55)
     }.call
     
     p1 = proc{i7 = 0; proc{i7}}.call
-    assert(p1.call == 0)
+    assert_equal(p1.call, 0)
     eval "i7=5", p1
-    assert(p1.call == 5)
+    assert_equal(p1.call, 5)
     assert(!defined?(i7))
     
     p1 = proc{i7 = 0; proc{i7}}.call
     i7 = nil
-    assert(p1.call == 0)
+    assert_equal(p1.call, 0)
     eval "i7=1", p1
-    assert(p1.call == 1)
+    assert_equal(p1.call, 1)
     eval "i7=5", p1
-    assert(p1.call == 5)
-    assert(i7 == nil)
+    assert_equal(p1.call, 5)
+    assert_equal(i7, nil)
   end
 end
diff --git a/test/ruby/test_float.rb b/test/ruby/test_float.rb
index 1541fa71ea..e639909761 100644
--- a/test/ruby/test_float.rb
+++ b/test/ruby/test_float.rb
@@ -4,23 +4,23 @@ $KCODE = 'none'
 
 class TestFloat < Test::Unit::TestCase
   def test_float
-    assert(2.6.floor == 2)
-    assert((-2.6).floor == -3)
-    assert(2.6.ceil == 3)
-    assert((-2.6).ceil == -2)
-    assert(2.6.truncate == 2)
-    assert((-2.6).truncate == -2)
-    assert(2.6.round == 3)
-    assert((-2.4).truncate == -2)
+    assert_equal(2.6.floor, 2)
+    assert_equal((-2.6).floor, -3)
+    assert_equal(2.6.ceil, 3)
+    assert_equal((-2.6).ceil, -2)
+    assert_equal(2.6.truncate, 2)
+    assert_equal((-2.6).truncate, -2)
+    assert_equal(2.6.round, 3)
+    assert_equal((-2.4).truncate, -2)
     assert((13.4 % 1 - 0.4).abs < 0.0001)
     nan = 0.0/0
     def nan.test(v)
       extend Test::Unit::Assertions
       assert(self != v)
-      assert((self < v) == false)
-      assert((self > v) == false)
-      assert((self <= v) == false)
-      assert((self >= v) == false)
+      assert_equal((self < v), false)
+      assert_equal((self > v), false)
+      assert_equal((self <= v), false)
+      assert_equal((self >= v), false)
     end
     nan.test(nan)
     nan.test(0)
@@ -40,6 +40,6 @@ class TestFloat < Test::Unit::TestCase
     #s = "3.7517675036461267e+17"
     #assert(s == sprintf("%.16e", s.to_f))
     f = 3.7517675036461267e+17
-    assert(f == sprintf("%.16e", f).to_f)
+    assert_equal(f, sprintf("%.16e", f).to_f)
   end
 end
diff --git a/test/ruby/test_hash.rb b/test/ruby/test_hash.rb
index d759c7cd4b..562ac93dfc 100644
--- a/test/ruby/test_hash.rb
+++ b/test/ruby/test_hash.rb
@@ -7,7 +7,7 @@ class TestHash < Test::Unit::TestCase
     $x = {1=>2, 2=>4, 3=>6}
     $y = {1, 2, 2, 4, 3, 6}
     
-    assert($x[1] == 2)
+    assert_equal($x[1], 2)
     
     assert(begin   
          for k,v in $y
@@ -18,48 +18,48 @@ class TestHash < Test::Unit::TestCase
          false
        end)
     
-    assert($x.length == 3)
+    assert_equal($x.length, 3)
     assert($x.has_key?(1))
     assert($x.has_value?(4))
-    assert($x.values_at(2,3) == [4,6])
-    assert($x == {1=>2, 2=>4, 3=>6})
+    assert_equal($x.values_at(2,3), [4,6])
+    assert_equal($x, {1=>2, 2=>4, 3=>6})
     
     $z = $y.keys.join(":")
-    assert($z == "1:2:3")
+    assert_equal($z, "1:2:3")
     
     $z = $y.values.join(":")
-    assert($z == "2:4:6")
-    assert($x == $y)
+    assert_equal($z, "2:4:6")
+    assert_equal($x, $y)
     
     $y.shift
-    assert($y.length == 2)
+    assert_equal($y.length, 2)
     
     $z = [1,2]
     $y[$z] = 256
-    assert($y[$z] == 256)
+    assert_equal($y[$z], 256)
     
     $x = Hash.new(0)
     $x[1] = 1
-    assert($x[1] == 1)
-    assert($x[2] == 0)
+    assert_equal($x[1], 1)
+    assert_equal($x[2], 0)
     
     $x = Hash.new([])
-    assert($x[22] == [])
+    assert_equal($x[22], [])
     assert($x[22].equal?($x[22]))
     
     $x = Hash.new{[]}
-    assert($x[22] == [])
+    assert_equal($x[22], [])
     assert(!$x[22].equal?($x[22]))
     
     $x = Hash.new{|h,k| $z = k; h[k] = k*2}
     $z = 0
-    assert($x[22] == 44)
-    assert($z == 22)
+    assert_equal($x[22], 44)
+    assert_equal($z, 22)
     $z = 0
-    assert($x[22] == 44)
-    assert($z == 0)
+    assert_equal($x[22], 44)
+    assert_equal($z, 0)
     $x.default = 5
-    assert($x[23] == 5)
+    assert_equal($x[23], 5)
     
     $x = Hash.new
     def $x.default(k)
@@ -67,10 +67,10 @@ class TestHash < Test::Unit::TestCase
       self[k] = k*2
     end
     $z = 0
-    assert($x[22] == 44)
-    assert($z == 22)
+    assert_equal($x[22], 44)
+    assert_equal($z, 22)
     $z = 0
-    assert($x[22] == 44)
-    assert($z == 0)
+    assert_equal($x[22], 44)
+    assert_equal($z, 0)
   end
 end
diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb
index 96fd1542b0..4b9e7c17a1 100644
--- a/test/ruby/test_iterator.rb
+++ b/test/ruby/test_iterator.rb
@@ -239,13 +239,13 @@ class TestIterator < Test::Unit::TestCase
     block = get_block{11}
     assert_instance_of(Proc, block)
     assert_instance_of(Proc, block.to_proc)
-    assert(block.clone.call == 11)
+    assert_equal(block.clone.call, 11)
     assert_instance_of(Proc, get_block(&block))
 
     lambda = lambda{44}
     assert_instance_of(Proc, lambda)
     assert_instance_of(Proc, lambda.to_proc)
-    assert(lambda.clone.call == 44)
+    assert_equal(lambda.clone.call, 44)
     assert_instance_of(Proc, get_block(&lambda))
 
     assert_equal(1, Proc.new{|a,| a}.call(1,2,3))
diff --git a/test/ruby/test_marshal.rb b/test/ruby/test_marshal.rb
index 5564fd1e7b..7058c428ea 100644
--- a/test/ruby/test_marshal.rb
+++ b/test/ruby/test_marshal.rb
@@ -26,7 +26,7 @@ class TestMarshal < Test::Unit::TestCase
       a = (x.to_f + y.to_f / z.to_f) * Math.exp(w.to_f / (x.to_f + y.to_f / z.to_f))
       ma = Marshal.dump(a)
       b = Marshal.load(ma)
-      assert(a == b)
+      assert_equal(a, b)
     }
   end
 end
diff --git a/test/ruby/test_math.rb b/test/ruby/test_math.rb
index 15537159a3..58041eaa35 100644
--- a/test/ruby/test_math.rb
+++ b/test/ruby/test_math.rb
@@ -4,11 +4,11 @@ $KCODE = 'none'
 
 class TestMath < Test::Unit::TestCase
   def test_math
-    assert(Math.sqrt(4) == 2)
+    assert_equal(Math.sqrt(4), 2)
     
     self.class.class_eval {
       include Math
     }
-    assert(sqrt(4) == 2)
+    assert_equal(sqrt(4), 2)
   end
 end
diff --git a/test/ruby/test_pack.rb b/test/ruby/test_pack.rb
index 15b774f6ca..4bb17993f5 100644
--- a/test/ruby/test_pack.rb
+++ b/test/ruby/test_pack.rb
@@ -11,11 +11,11 @@ class TestPack < Test::Unit::TestCase
     $x = ary.pack($format)
     ary2 = $x.unpack($format)
     
-    assert(ary.length == ary2.length)
-    assert(ary.join(':') == ary2.join(':'))
+    assert_equal(ary.length, ary2.length)
+    assert_equal(ary.join(':'), ary2.join(':'))
     assert($x =~ /def/)
     
     $x = [-1073741825]
-    assert($x.pack("q").unpack("q") == $x)
+    assert_equal($x.pack("q").unpack("q"), $x)
   end
 end
diff --git a/test/ruby/test_path.rb b/test/ruby/test_path.rb
index d13ec66d30..9faee72add 100644
--- a/test/ruby/test_path.rb
+++ b/test/ruby/test_path.rb
@@ -4,25 +4,25 @@ $KCODE = 'none'
 
 class TestPath < Test::Unit::TestCase
   def test_path
-    assert(File.basename("a") == "a")
-    assert(File.basename("a/b") == "b")
-    assert(File.basename("a/b/") == "b")
-    assert(File.basename("/") == "/")
-    assert(File.basename("//") == "/")
-    assert(File.basename("///") == "/")
-    assert(File.basename("a/b////") == "b")
-    assert(File.basename("a.rb", ".rb") == "a")
-    assert(File.basename("a.rb///", ".rb") == "a")
-    assert(File.basename("a.rb///", ".*") == "a")
-    assert(File.basename("a.rb///", ".c") == "a.rb")
-    assert(File.dirname("a") == ".")
-    assert(File.dirname("/") == "/")
-    assert(File.dirname("/a") == "/")
-    assert(File.dirname("a/b") == "a")
-    assert(File.dirname("a/b/c") == "a/b")
-    assert(File.dirname("/a/b/c") == "/a/b")
-    assert(File.dirname("/a/b/") == "/a")
-    assert(File.dirname("/a/b///") == "/a")
+    assert_equal(File.basename("a"), "a")
+    assert_equal(File.basename("a/b"), "b")
+    assert_equal(File.basename("a/b/"), "b")
+    assert_equal(File.basename("/"), "/")
+    assert_equal(File.basename("//"), "/")
+    assert_equal(File.basename("///"), "/")
+    assert_equal(File.basename("a/b////"), "b")
+    assert_equal(File.basename("a.rb", ".rb"), "a")
+    assert_equal(File.basename("a.rb///", ".rb"), "a")
+    assert_equal(File.basename("a.rb///", ".*"), "a")
+    assert_equal(File.basename("a.rb///", ".c"), "a.rb")
+    assert_equal(File.dirname("a"), ".")
+    assert_equal(File.dirname("/"), "/")
+    assert_equal(File.dirname("/a"), "/")
+    assert_equal(File.dirname("a/b"), "a")
+    assert_equal(File.dirname("a/b/c"), "a/b")
+    assert_equal(File.dirname("/a/b/c"), "/a/b")
+    assert_equal(File.dirname("/a/b/"), "/a")
+    assert_equal(File.dirname("/a/b///"), "/a")
     case Dir.pwd
     when %r'\A\w:'
       assert(/\A\w:\/\z/ =~ File.expand_path(".", "/"))
@@ -33,16 +33,16 @@ class TestPath < Test::Unit::TestCase
       assert(%r'\A//[^/]+/[^/]+/a\z' =~ File.expand_path(".", "/"))
       dosish = true
     else
-      assert(File.expand_path(".", "/") == "/")
-      assert(File.expand_path("sub", "/") == "/sub")
+      assert_equal(File.expand_path(".", "/"), "/")
+      assert_equal(File.expand_path("sub", "/"), "/sub")
     end
     if dosish
-      assert(File.expand_path("/", "//machine/share/sub") == "//machine/share")
-      assert(File.expand_path("/dir", "//machine/share/sub") == "//machine/share/dir")
-      assert(File.expand_path("/", "z:/sub") == "z:/")
-      assert(File.expand_path("/dir", "z:/sub") == "z:/dir")
+      assert_equal(File.expand_path("/", "//machine/share/sub"), "//machine/share")
+      assert_equal(File.expand_path("/dir", "//machine/share/sub"), "//machine/share/dir")
+      assert_equal(File.expand_path("/", "z:/sub"), "z:/")
+      assert_equal(File.expand_path("/dir", "z:/sub"), "z:/dir")
     end
-    assert(File.expand_path(".", "//") == "//")
-    assert(File.expand_path("sub", "//") == "//sub")
+    assert_equal(File.expand_path(".", "//"), "//")
+    assert_equal(File.expand_path("sub", "//"), "//sub")
   end
 end
diff --git a/test/ruby/test_proc.rb b/test/ruby/test_proc.rb
index 0cf470ff00..893bc3f1a1 100644
--- a/test/ruby/test_proc.rb
+++ b/test/ruby/test_proc.rb
@@ -5,12 +5,12 @@ $KCODE = 'none'
 class TestProc < Test::Unit::TestCase
   def test_proc
     $proc = proc{|i| i}
-    assert($proc.call(2) == 2)
-    assert($proc.call(3) == 3)
+    assert_equal($proc.call(2), 2)
+    assert_equal($proc.call(3), 3)
     
     $proc = proc{|i| i*2}
-    assert($proc.call(2) == 4)
-    assert($proc.call(3) == 6)
+    assert_equal($proc.call(2), 4)
+    assert_equal($proc.call(3), 6)
     
     proc{
       iii=5				# nested local variable
@@ -40,6 +40,6 @@ class TestProc < Test::Unit::TestCase
     $x=0
     $proc.call(5)
     $proc2.call
-    assert($x == 5)
+    assert_equal($x, 5)
   end
 end
diff --git a/test/ruby/test_signal.rb b/test/ruby/test_signal.rb
index d9376b47ea..eabeedc38a 100644
--- a/test/ruby/test_signal.rb
+++ b/test/ruby/test_signal.rb
@@ -9,7 +9,7 @@ class TestSignal < Test::Unit::TestCase
       trap "SIGINT", proc{|sig| $x = 2}
       Process.kill "SIGINT", $$
       sleep 0.1
-      assert($x == 2)
+      assert_equal($x, 2)
     
       trap "SIGINT", proc{raise "Interrupt"}
     
diff --git a/test/ruby/test_stringchar.rb b/test/ruby/test_stringchar.rb
index 498300f379..78ec39d56c 100644
--- a/test/ruby/test_stringchar.rb
+++ b/test/ruby/test_stringchar.rb
@@ -3,18 +3,18 @@ require 'test/unit'
 $KCODE = 'none'
 
 class TestStringchar < Test::Unit::TestCase
-  def test_stringchar
-    assert("abcd" == "abcd")
+  def test_string
+    assert_equal("abcd", "abcd")
     assert("abcd" =~ /abcd/)
     assert("abcd" === "abcd")
     # compile time string concatenation
-    assert("ab" "cd" == "abcd")
-    assert("#{22}aa" "cd#{44}" == "22aacd44")
-    assert("#{22}aa" "cd#{44}" "55" "#{66}" == "22aacd445566")
+    assert_equal("ab" "cd", "abcd")
+    assert_equal("#{22}aa" "cd#{44}", "22aacd44")
+    assert_equal("#{22}aa" "cd#{44}" "55" "#{66}", "22aacd445566")
     assert("abc" !~ /^$/)
     assert("abc\n" !~ /^$/)
     assert("abc" !~ /^d*$/)
-    assert(("abc" =~ /d*$/) == 3)
+    assert_equal(("abc" =~ /d*$/), 3)
     assert("" =~ /^$/)
     assert("\n" =~ /^$/)
     assert("a\n\n" =~ /^$/)
@@ -37,46 +37,48 @@ ABCD
 ABCD
 END
     $x.gsub!(/((.|\n)*?)B((.|\n)*?)D/){$1+$3}
-    assert($x == "AC\nAC\n")
+    assert_equal($x, "AC\nAC\n")
     
     assert("foobar" =~ /foo(?=(bar)|(baz))/)
     assert("foobaz" =~ /foo(?=(bar)|(baz))/)
     
     $foo = "abc"
-    assert("#$foo = abc" == "abc = abc")
-    assert("#{$foo} = abc" == "abc = abc")
+    assert_equal("#$foo = abc", "abc = abc")
+    assert_equal("#{$foo} = abc", "abc = abc")
     
     foo = "abc"
-    assert("#{foo} = abc" == "abc = abc")
+    assert_equal("#{foo} = abc", "abc = abc")
     
-    assert('-' * 5 == '-----')
-    assert('-' * 1 == '-')
-    assert('-' * 0 == '')
+    assert_equal('-' * 5, '-----')
+    assert_equal('-' * 1, '-')
+    assert_equal('-' * 0, '')
     
     foo = '-'
-    assert(foo * 5 == '-----')
-    assert(foo * 1 == '-')
-    assert(foo * 0 == '')
+    assert_equal(foo * 5, '-----')
+    assert_equal(foo * 1, '-')
+    assert_equal(foo * 0, '')
     
     $x = "a.gif"
-    assert($x.sub(/.*\.([^\.]+)$/, '\1') == "gif")
-    assert($x.sub(/.*\.([^\.]+)$/, 'b.\1') == "b.gif")
-    assert($x.sub(/.*\.([^\.]+)$/, '\2') == "")
-    assert($x.sub(/.*\.([^\.]+)$/, 'a\2b') == "ab")
-    assert($x.sub(/.*\.([^\.]+)$/, '<\&>') == "<a.gif>")
-    
+    assert_equal($x.sub(/.*\.([^\.]+)$/, '\1'), "gif")
+    assert_equal($x.sub(/.*\.([^\.]+)$/, 'b.\1'), "b.gif")
+    assert_equal($x.sub(/.*\.([^\.]+)$/, '\2'), "")
+    assert_equal($x.sub(/.*\.([^\.]+)$/, 'a\2b'), "ab")
+    assert_equal($x.sub(/.*\.([^\.]+)$/, '<\&>'), "<a.gif>")
+  end
+
+  def test_char
     # character constants(assumes ASCII)
-    assert("a"[0] == ?a)
-    assert(?a == ?a)
-    assert(?\C-a == 1)
-    assert(?\M-a == 225)
-    assert(?\M-\C-a == 129)
-    assert("a".upcase![0] == ?A)
-    assert("A".downcase![0] == ?a)
-    assert("abc".tr!("a-z", "A-Z") == "ABC")
-    assert("aabbcccc".tr_s!("a-z", "A-Z") == "ABC")
-    assert("abcc".squeeze!("a-z") == "abc")
-    assert("abcd".delete!("bc") == "ad")
+    assert_equal("a"[0], ?a)
+    assert_equal(?a, ?a)
+    assert_equal(?\C-a, 1)
+    assert_equal(?\M-a, 225)
+    assert_equal(?\M-\C-a, 129)
+    assert_equal("a".upcase![0], ?A)
+    assert_equal("A".downcase![0], ?a)
+    assert_equal("abc".tr!("a-z", "A-Z"), "ABC")
+    assert_equal("aabbcccc".tr_s!("a-z", "A-Z"), "ABC")
+    assert_equal("abcc".squeeze!("a-z"), "abc")
+    assert_equal("abcd".delete!("bc"), "ad")
     
     $x = "abcdef"
     $y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
@@ -91,26 +93,26 @@ END
     
     s = "a string"
     s[0..s.size]="another string"
-    assert(s == "another string")
+    assert_equal(s, "another string")
     
     s = <<EOS
 #{
 [1,2,3].join(",")
 }
 EOS
-    assert(s == "1,2,3\n")
-    assert("Just".to_i(36) == 926381)
-    assert("-another".to_i(36) == -23200231779)
-    assert(1299022.to_s(36) == "ruby")
-    assert(-1045307475.to_s(36) == "-hacker")
-    assert("Just_another_Ruby_hacker".to_i(36) == 265419172580680477752431643787347)
-    assert(-265419172580680477752431643787347.to_s(36) == "-justanotherrubyhacker")
+    assert_equal(s, "1,2,3\n")
+    assert_equal("Just".to_i(36), 926381)
+    assert_equal("-another".to_i(36), -23200231779)
+    assert_equal(1299022.to_s(36), "ruby")
+    assert_equal(-1045307475.to_s(36), "-hacker")
+    assert_equal("Just_another_Ruby_hacker".to_i(36), 265419172580680477752431643787347)
+    assert_equal(-265419172580680477752431643787347.to_s(36), "-justanotherrubyhacker")
     
     a = []
     (0..255).each {|n|
       ch = [n].pack("C")                     
       a.push ch if /a#{Regexp.quote ch}b/x =~ "ab" 
     }
-    assert(a.size == 0)
+    assert_equal(a.size, 0)
   end
 end
diff --git a/test/ruby/test_struct.rb b/test/ruby/test_struct.rb
index 2d50e9c198..e02f791f27 100644
--- a/test/ruby/test_struct.rb
+++ b/test/ruby/test_struct.rb
@@ -5,7 +5,7 @@ $KCODE = 'none'
 class TestStruct < Test::Unit::TestCase
   def test_struct
     struct_test = Struct.new("Test", :foo, :bar)
-    assert(struct_test == Struct::Test)
+    assert_equal(struct_test, Struct::Test)
     
     test = struct_test.new(1, 2)
     assert(test.foo == 1 && test.bar == 2)
@@ -15,9 +15,9 @@ class TestStruct < Test::Unit::TestCase
     assert(a == 1 && b == 2)
     
     test[0] = 22
-    assert(test.foo == 22)
+    assert_equal(test.foo, 22)
     
     test.bar = 47
-    assert(test.bar == 47)
+    assert_equal(test.bar, 47)
   end 
 end
diff --git a/test/ruby/test_system.rb b/test/ruby/test_system.rb
index b2858e5a8a..4b4eb77126 100644
--- a/test/ruby/test_system.rb
+++ b/test/ruby/test_system.rb
@@ -9,22 +9,22 @@ class TestSystem < Test::Unit::TestCase
     else
       ruby = "ruby"
     end
-    assert(`echo foobar` == "foobar\n")
-    assert(`#{ruby} -e 'print "foobar"'` == 'foobar')
+    assert_equal(`echo foobar`, "foobar\n")
+    assert_equal(`#{ruby} -e 'print "foobar"'`, 'foobar')
     
     tmp = open("script_tmp", "w")
     tmp.print "print $zzz\n";
     tmp.close
     
-    assert(`#{ruby} -s script_tmp -zzz` == 'true')
-    assert(`#{ruby} -s script_tmp -zzz=555` == '555')
+    assert_equal(`#{ruby} -s script_tmp -zzz`, 'true')
+    assert_equal(`#{ruby} -s script_tmp -zzz=555`, '555')
     
     tmp = open("script_tmp", "w")
     tmp.print "#! /usr/local/bin/ruby -s\n";
     tmp.print "print $zzz\n";
     tmp.close
     
-    assert(`#{ruby} script_tmp -zzz=678` == '678')
+    assert_equal(`#{ruby} script_tmp -zzz=678`, '678')
     
     tmp = open("script_tmp", "w")
     tmp.print "this is a leading junk\n";
@@ -34,8 +34,8 @@ class TestSystem < Test::Unit::TestCase
     tmp.print "this is a trailing junk\n";
     tmp.close
     
-    assert(`#{ruby} -x script_tmp` == 'nil')
-    assert(`#{ruby} -x script_tmp -zzz=555` == '555')
+    assert_equal(`#{ruby} -x script_tmp`, 'nil')
+    assert_equal(`#{ruby} -x script_tmp -zzz=555`, '555')
     
     tmp = open("script_tmp", "w")
     for i in 1..5
diff --git a/test/ruby/test_trace.rb b/test/ruby/test_trace.rb
index 74fb1148f0..4201e63c47 100644
--- a/test/ruby/test_trace.rb
+++ b/test/ruby/test_trace.rb
@@ -8,7 +8,7 @@ class TestTrace < Test::Unit::TestCase
     $y = 0
     trace_var :$x, proc{$y = $x}
     $x = 40414
-    assert($y == $x)
+    assert_equal($y, $x)
     
     untrace_var :$x
     $x = 19660208
@@ -16,7 +16,7 @@ class TestTrace < Test::Unit::TestCase
     
     trace_var :$x, proc{$x *= 2}
     $x = 5
-    assert($x == 10)
+    assert_equal($x, 10)
     
     untrace_var :$x
   end 
diff --git a/test/ruby/test_variable.rb b/test/ruby/test_variable.rb
index c4a17b7caf..9d982882da 100644
--- a/test/ruby/test_variable.rb
+++ b/test/ruby/test_variable.rb
@@ -44,15 +44,15 @@ class TestVariable < Test::Unit::TestCase
     
     foobar = "foobar"
     $_ = foobar
-    assert($_ == foobar)
+    assert_equal($_, foobar)
 
-    assert(Gods.new.ruler0 == "Cronus")
-    assert(Gods.ruler1 == "Cronus")
-    assert(Gods.ruler2 == "Cronus")
-    assert(Titans.ruler1 == "Cronus")
-    assert(Titans.ruler2 == "Cronus")
+    assert_equal(Gods.new.ruler0, "Cronus")
+    assert_equal(Gods.ruler1, "Cronus")
+    assert_equal(Gods.ruler2, "Cronus")
+    assert_equal(Titans.ruler1, "Cronus")
+    assert_equal(Titans.ruler2, "Cronus")
     atlas = Titans.new
-    assert(atlas.ruler0 == "Cronus")
-    assert(atlas.ruler3 == "Zeus")
+    assert_equal(atlas.ruler0, "Cronus")
+    assert_equal(atlas.ruler3, "Zeus")
   end
 end
diff --git a/test/ruby/test_whileuntil.rb b/test/ruby/test_whileuntil.rb
index 89ae2b6d6b..ecbfed2f7a 100644
--- a/test/ruby/test_whileuntil.rb
+++ b/test/ruby/test_whileuntil.rb
@@ -54,7 +54,7 @@ class TestWhileuntil < Test::Unit::TestCase
         redo
       end
     end
-    assert(sum == 220)
+    assert_equal(sum, 220)
     
     $bad = false
     tmp = open("while_tmp", "r")