From 65264eadbd3a8e1a3a96024e559a4a72d97c71e4 Mon Sep 17 00:00:00 2001 From: nahi Date: Fri, 5 Sep 2003 11:28:27 +0000 Subject: * 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 --- ChangeLog | 4 + test/ruby/test_alias.rb | 6 +- test/ruby/test_array.rb | 66 ++--- test/ruby/test_assignment.rb | 652 +++++++++++++++++++++---------------------- test/ruby/test_bignum.rb | 46 +-- test/ruby/test_call.rb | 8 +- test/ruby/test_clone.rb | 8 +- test/ruby/test_const.rb | 10 +- test/ruby/test_defined.rb | 4 +- test/ruby/test_eval.rb | 48 ++-- test/ruby/test_float.rb | 26 +- test/ruby/test_hash.rb | 44 +-- test/ruby/test_iterator.rb | 4 +- test/ruby/test_marshal.rb | 2 +- test/ruby/test_math.rb | 4 +- test/ruby/test_pack.rb | 6 +- test/ruby/test_path.rb | 54 ++-- test/ruby/test_proc.rb | 10 +- test/ruby/test_signal.rb | 2 +- test/ruby/test_stringchar.rb | 86 +++--- test/ruby/test_struct.rb | 6 +- test/ruby/test_system.rb | 14 +- test/ruby/test_trace.rb | 4 +- test/ruby/test_variable.rb | 16 +- test/ruby/test_whileuntil.rb | 2 +- 25 files changed, 569 insertions(+), 563 deletions(-) diff --git a/ChangeLog b/ChangeLog index 65b101b6a5..66a2e972ad 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +Fri Sep 5 20:27:08 2003 NAKAMURA, Hiroshi + + * test/ruby/test_*.rb: replace 'assert(a == b)' with assert_equal(a, b)' + Fri Sep 5 18:00:51 2003 GOTOU Yuuzou * ext/openssl/lib/openssl/x509.rb: new method X509::Name::parse. 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(/.*\.([^\.]+)$/, '<\&>') == "") - + 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(/.*\.([^\.]+)$/, '<\&>'), "") + 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 = <