From 44785befeabd09d5d34f33b33783c0ec54f06a1f Mon Sep 17 00:00:00 2001 From: nobu Date: Fri, 5 Sep 2003 15:15:43 +0000 Subject: * lib/optparse.rb (OptionParser#order, #permute, #parse): allow an array as argument. * test/ruby/test_*.rb: moved invariants to left side in assert_equal, and use assert_nil, assert_raises and so on. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4516 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- test/ruby/test_alias.rb | 10 +- test/ruby/test_array.rb | 86 +++--- test/ruby/test_assignment.rb | 680 +++++++++++++++++++++---------------------- test/ruby/test_bignum.rb | 53 ++-- test/ruby/test_call.rb | 25 +- test/ruby/test_case.rb | 8 +- test/ruby/test_clone.rb | 23 +- test/ruby/test_condition.rb | 4 +- test/ruby/test_const.rb | 20 +- test/ruby/test_defined.rb | 12 +- test/ruby/test_eval.rb | 68 ++--- test/ruby/test_exception.rb | 33 ++- test/ruby/test_float.rb | 26 +- test/ruby/test_gc.rb | 5 +- test/ruby/test_hash.rb | 68 ++--- test/ruby/test_iterator.rb | 6 +- test/ruby/test_marshal.rb | 2 +- test/ruby/test_math.rb | 6 +- test/ruby/test_pack.rb | 6 +- test/ruby/test_path.rb | 62 ++-- test/ruby/test_proc.rb | 18 +- test/ruby/test_signal.rb | 14 +- test/ruby/test_stringchar.rb | 128 ++++---- test/ruby/test_struct.rb | 25 +- test/ruby/test_system.rb | 61 ++-- test/ruby/test_trace.rb | 12 +- test/ruby/test_variable.rb | 22 +- test/ruby/test_whileuntil.rb | 41 ++- 28 files changed, 742 insertions(+), 782 deletions(-) (limited to 'test/ruby') diff --git a/test/ruby/test_alias.rb b/test/ruby/test_alias.rb index 840bde4f54..50fe452734 100644 --- a/test/ruby/test_alias.rb +++ b/test/ruby/test_alias.rb @@ -28,12 +28,12 @@ class TestAlias < Test::Unit::TestCase def test_alias x = Alias2.new - assert_equal(x.bar, "foo") - assert_equal(x.baz, "foo+foo") - + assert_equal("foo", x.bar) + assert_equal("foo+foo", x.baz) + # test_check for cache - assert_equal(x.baz, "foo+foo") - + assert_equal("foo+foo", x.baz) + x = Alias3.new assert(!x.foo) assert(x.bar) diff --git a/test/ruby/test_array.rb b/test/ruby/test_array.rb index de82032221..ed2ee5961c 100644 --- a/test/ruby/test_array.rb +++ b/test/ruby/test_array.rb @@ -4,47 +4,47 @@ $KCODE = 'none' class TestArray < Test::Unit::TestCase def test_array - 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_equal([1, 2, 3, 4], [1, 2] + [3, 4]) + assert_equal([1, 2, 1, 2], [1, 2] * 2) + assert_equal("1:2", [1, 2] * ":") + assert_equal([1, 2].hash, [1, 2].hash) - - assert_equal([1,2,3] & [2,3,4], [2,3]) - assert_equal([1,2,3] | [2,3,4], [1,2,3,4]) + + assert_equal([2,3], [1,2,3] & [2,3,4]) + assert_equal([1,2,3,4], [1,2,3] | [2,3,4]) assert_equal([1,2,3] - [2,3], [1]) - + $x = [0, 1, 2, 3, 4, 5] - assert_equal($x[2], 2) - assert_equal($x[1..3], [1, 2, 3]) - assert_equal($x[1,3], [1, 2, 3]) - + assert_equal(2, $x[2]) + assert_equal([1, 2, 3], $x[1..3]) + assert_equal([1, 2, 3], $x[1,3]) + $x[0, 2] = 10 assert($x[0] == 10 && $x[1] == 2) - + $x[0, 0] = -1 assert($x[0] == -1 && $x[1] == 10) - + $x[-1, 1] = 20 assert($x[-1] == 20 && $x.pop == 20) end def test_array_andor - assert_equal(([1,2,3]&[2,4,6]), [2]) - assert_equal(([1,2,3]|[2,4,6]), [1,2,3,4,6]) + assert_equal([2], ([1,2,3]&[2,4,6])) + assert_equal([1,2,3,4,6], ([1,2,3]|[2,4,6])) end - + def test_compact $x = [nil, 1, nil, nil, 5, nil, nil] $x.compact! - assert_equal($x, [1, 5]) + assert_equal([1, 5], $x) end def test_uniq $x = [1, 1, 4, 2, 5, 4, 5, 1, 2] $x.uniq! - assert_equal($x, [1, 4, 2, 5]) - + assert_equal([1, 4, 2, 5], $x) + # empty? assert(!$x.empty?) $x = [] @@ -54,50 +54,50 @@ class TestArray < Test::Unit::TestCase def test_sort $x = ["it", "came", "to", "pass", "that", "..."] $x = $x.sort.join(" ") - assert_equal($x, "... came it pass that to") + assert_equal("... came it pass that to", $x) $x = [2,5,3,1,7] $x.sort!{|a,b| a<=>b} # sort with condition - assert_equal($x, [1,2,3,5,7]) + assert_equal([1,2,3,5,7], $x) $x.sort!{|a,b| b-a} # reverse sort - assert_equal($x, [7,5,3,2,1]) + assert_equal([7,5,3,2,1], $x) end def test_split $x = "The Boassert of Mormon" - assert_equal($x.split(//).reverse!.join, $x.reverse) + assert_equal($x.reverse, $x.split(//).reverse!.join) 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") + assert_equal("g:n:i:r:t:s: :e:t:y:b: :1", "1 byte string".split(//).reverse.join(":")) $x = "a b c d" - assert_equal($x.split, ['a', 'b', 'c', 'd']) - assert_equal($x.split(' '), ['a', 'b', 'c', 'd']) + assert_equal(['a', 'b', 'c', 'd'], $x.split) + assert_equal(['a', 'b', 'c', 'd'], $x.split(' ')) end def test_misc assert(defined? "a".chomp) - assert_equal("abc".scan(/./), ["a", "b", "c"]) - assert_equal("1a2b3c".scan(/(\d.)/), [["1a"], ["2b"], ["3c"]]) + assert_equal(["a", "b", "c"], "abc".scan(/./)) + assert_equal([["1a"], ["2b"], ["3c"]], "1a2b3c".scan(/(\d.)/)) # non-greedy match - assert_equal("a=12;b=22".scan(/(.*?)=(\d*);?/), [["a", "12"], ["b", "22"]]) - + assert_equal([["a", "12"], ["b", "22"]], "a=12;b=22".scan(/(.*?)=(\d*);?/)) + $x = [1] - assert_equal(($x * 5).join(":"), '1:1:1:1:1') - assert_equal(($x * 1).join(":"), '1') - assert_equal(($x * 0).join(":"), '') - + assert_equal('1:1:1:1:1', ($x * 5).join(":")) + assert_equal('1', ($x * 1).join(":")) + assert_equal('', ($x * 0).join(":")) + *$x = *(1..7).to_a - assert_equal($x.size, 7) - assert_equal($x, [1, 2, 3, 4, 5, 6, 7]) - + assert_equal(7, $x.size) + assert_equal([1, 2, 3, 4, 5, 6, 7], $x) + $x = [1,2,3] $x[1,0] = $x - assert_equal($x, [1,1,2,3,2,3]) - + assert_equal([1,1,2,3,2,3], $x) + $x = [1,2,3] $x[-1,0] = $x - assert_equal($x, [1,2,1,2,3,3]) - + assert_equal([1,2,1,2,3,3], $x) + $x = [1,2,3] $x.concat($x) - assert_equal($x, [1,2,3,1,2,3]) + assert_equal([1,2,3,1,2,3], $x) end end diff --git a/test/ruby/test_assignment.rb b/test/ruby/test_assignment.rb index 9a3e3a1636..51d1c780f8 100644 --- a/test/ruby/test_assignment.rb +++ b/test/ruby/test_assignment.rb @@ -5,275 +5,275 @@ $KCODE = 'none' class TestAssignment < Test::Unit::TestCase def test_assign a=[]; a[0] ||= "bar"; - assert_equal(a[0], "bar") + assert_equal("bar", a[0]) h={}; h["foo"] ||= "bar"; - assert_equal(h["foo"], "bar") - + assert_equal("bar", h["foo"]) + aa = 5 aa ||= 25 - assert_equal(aa, 5) + assert_equal(5, aa) bb ||= 25 - assert_equal(bb, 25) + assert_equal(25, bb) cc &&=33 - assert_equal(cc, nil) + assert_nil(cc) cc = 5 cc &&=44 - 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,[]]) + assert_equal(44, cc) + + a = nil; assert_nil(a) + a = 1; assert_equal(1, a) + a = []; assert_equal([], a) + a = [1]; assert_equal([1], a) + a = [nil]; assert_equal([nil], a) + a = [[]]; assert_equal([[]], a) + a = [1,2]; assert_equal([1,2], a) + a = [*[]]; assert_equal([], a) + a = [*[1]]; assert_equal([1], a) + a = [*[1,2]]; assert_equal([1,2], a) + + a = *nil; assert_nil(a) + a = *1; assert_equal(1, a) + a = *[]; assert_nil(a) + a = *[1]; assert_equal(1, a) + a = *[nil]; assert_nil(a) + a = *[[]]; assert_equal([], a) + a = *[1,2]; assert_equal([1,2], a) + a = *[*[]]; assert_nil(a) + a = *[*[1]]; assert_equal(1, a) + a = *[*[1,2]]; assert_equal([1,2], a) + + *a = nil; assert_equal([nil], a) + *a = 1; assert_equal([1], a) + *a = []; assert_equal([[]], a) + *a = [1]; assert_equal([[1]], a) + *a = [nil]; assert_equal([[nil]], a) + *a = [[]]; assert_equal([[[]]], a) + *a = [1,2]; assert_equal([[1,2]], a) + *a = [*[]]; assert_equal([[]], a) + *a = [*[1]]; assert_equal([[1]], a) + *a = [*[1,2]]; assert_equal([[1,2]], a) + + *a = *nil; assert_equal([nil], a) + *a = *1; assert_equal([1], a) + *a = *[]; assert_equal([], a) + *a = *[1]; assert_equal([1], a) + *a = *[nil]; assert_equal([nil], a) + *a = *[[]]; assert_equal([[]], a) + *a = *[1,2]; assert_equal([1,2], a) + *a = *[*[]]; assert_equal([], a) + *a = *[*[1]]; assert_equal([1], a) + *a = *[*[1,2]]; assert_equal([1,2], a) + + a,b,*c = nil; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = 1; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = []; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = [1]; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = [nil]; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = [[]]; assert_equal([[],nil,[]], [a,b,c]) + a,b,*c = [1,2]; assert_equal([1,2,[]], [a,b,c]) + a,b,*c = [*[]]; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = [*[1]]; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = [*[1,2]]; assert_equal([1,2,[]], [a,b,c]) + + a,b,*c = *nil; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = *1; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = *[]; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = *[1]; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = *[nil]; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = *[[]]; assert_equal([[],nil,[]], [a,b,c]) + a,b,*c = *[1,2]; assert_equal([1,2,[]], [a,b,c]) + a,b,*c = *[*[]]; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = *[*[1]]; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = *[*[1,2]]; assert_equal([1,2,[]], [a,b,c]) end def test_yield - 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,[]])} + def f; yield nil; end; f {|a| assert_nil(a)} + def f; yield 1; end; f {|a| assert_equal(1, a)} + def f; yield []; end; f {|a| assert_equal([], a)} + def f; yield [1]; end; f {|a| assert_equal([1], a)} + def f; yield [nil]; end; f {|a| assert_equal([nil], a)} + 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([1], a)} + def f; yield [*[1,2]]; end; f {|a| assert_equal([1,2], a)} + + def f; yield *nil; end; f {|a| assert_nil(a)} + def f; yield *1; end; f {|a| assert_equal(1, a)} + def f; yield *[1]; end; f {|a| assert_equal(1, a)} + def f; yield *[nil]; end; f {|a| assert_nil(a)} + def f; yield *[[]]; end; f {|a| assert_equal([], a)} + def f; yield *[*[1]]; end; f {|a| assert_equal(1, a)} + + def f; yield; end; f {|*a| assert_equal([], a)} + def f; yield nil; end; f {|*a| assert_equal([nil], a)} + def f; yield 1; end; f {|*a| assert_equal([1], a)} + def f; yield []; end; f {|*a| assert_equal([[]], a)} + def f; yield [1]; end; f {|*a| assert_equal([[1]], a)} + def f; yield [nil]; end; f {|*a| assert_equal([[nil]], a)} + def f; yield [[]]; end; f {|*a| assert_equal([[[]]], a)} + def f; yield [1,2]; end; f {|*a| assert_equal([[1,2]], a)} + def f; yield [*[]]; end; f {|*a| assert_equal([[]], a)} + def f; yield [*[1]]; end; f {|*a| assert_equal([[1]], a)} + def f; yield [*[1,2]]; end; f {|*a| assert_equal([[1,2]], a)} + + def f; yield *nil; end; f {|*a| assert_equal([nil], a)} + def f; yield *1; end; f {|*a| assert_equal([1], a)} + def f; yield *[]; end; f {|*a| assert_equal([], a)} + def f; yield *[1]; end; f {|*a| assert_equal([1], a)} + def f; yield *[nil]; end; f {|*a| assert_equal([nil], a)} + 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([1], a)} + def f; yield *[*[1,2]]; end; f {|*a| assert_equal([1,2], a)} + + def f; yield; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield 1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])} + def f; yield []; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield [1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])} + def f; yield [nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield [[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])} + def f; yield [*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])} + def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])} + + def f; yield *nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield *1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])} + def f; yield *[]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield *[1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])} + def f; yield *[nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield *[[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])} + def f; yield *[*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])} + def f; yield *[*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])} + def f; yield *[*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])} end def test_return - 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,[]]) + def r; return; end; a = r(); assert_nil(a) + def r; return nil; end; a = r(); assert_nil(a) + def r; return 1; end; a = r(); assert_equal(1, a) + def r; return []; end; a = r(); assert_equal([], a) + def r; return [1]; end; a = r(); assert_equal([1], a) + def r; return [nil]; end; a = r(); assert_equal([nil], a) + 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([1], a) + def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a) + + def r; return *nil; end; a = r(); assert_nil(a) + def r; return *1; end; a = r(); assert_equal(1, a) + def r; return *[]; end; a = r(); assert_nil(a) + def r; return *[1]; end; a = r(); assert_equal(1, a) + def r; return *[nil]; end; a = r(); assert_nil(a) + def r; return *[[]]; end; a = r(); assert_equal([], a) + def r; return *[*[]]; end; a = r(); assert_nil(a) + def r; return *[*[1]]; end; a = r(); assert_equal(1, a) + def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a) + + def r; return *nil; end; a = *r(); assert_nil(a) + def r; return *1; end; a = *r(); assert_equal(1, a) + def r; return *[]; end; a = *r(); assert_nil(a) + def r; return *[1]; end; a = *r(); assert_equal(1, a) + def r; return *[nil]; end; a = *r(); assert_nil(a) + def r; return *[[]]; end; a = *r(); assert_nil(a) + def r; return *[*[]]; end; a = *r(); assert_nil(a) + def r; return *[*[1]]; end; a = *r(); assert_equal(1, a) + def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a) + + def r; return; end; *a = r(); assert_equal([nil], a) + def r; return nil; end; *a = r(); assert_equal([nil], a) + def r; return 1; end; *a = r(); assert_equal([1], a) + def r; return []; end; *a = r(); assert_equal([[]], a) + def r; return [1]; end; *a = r(); assert_equal([[1]], a) + def r; return [nil]; end; *a = r(); assert_equal([[nil]], a) + def r; return [[]]; end; *a = r(); assert_equal([[[]]], a) + def r; return [1,2]; end; *a = r(); assert_equal([[1,2]], a) + def r; return [*[]]; end; *a = r(); assert_equal([[]], a) + def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a) + def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a) + + def r; return *nil; end; *a = r(); assert_equal([nil], a) + def r; return *1; end; *a = r(); assert_equal([1], a) + def r; return *[]; end; *a = r(); assert_equal([nil], a) + def r; return *[1]; end; *a = r(); assert_equal([1], a) + def r; return *[nil]; end; *a = r(); assert_equal([nil], a) + def r; return *[[]]; end; *a = r(); assert_equal([[]], a) + def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a) + def r; return *[*[]]; end; *a = r(); assert_equal([nil], a) + def r; return *[*[1]]; end; *a = r(); assert_equal([1], a) + def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a) + + def r; return *nil; end; *a = *r(); assert_equal([nil], a) + def r; return *1; end; *a = *r(); assert_equal([1], a) + def r; return *[]; end; *a = *r(); assert_equal([nil], a) + def r; return *[1]; end; *a = *r(); assert_equal([1], a) + def r; return *[nil]; end; *a = *r(); assert_equal([nil], a) + def r; return *[[]]; end; *a = *r(); assert_equal([], a) + def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a) + def r; return *[*[]]; end; *a = *r(); assert_equal([nil], a) + def r; return *[*[1]]; end; *a = *r(); assert_equal([1], a) + def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a) + + def r; return; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return 1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]) + def r; return []; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return [1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]) + def r; return [nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return [[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c]) + def r; return [1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]) + def r; return [*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return [*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]) + def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]) + + def r; return *nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return *1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]) + def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]) + def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return *[[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]) + def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]) + def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]) + def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]) end def test_lambda f = lambda {|r,| assert_equal([], r)} f.call([], *[]) - + f = lambda {|r,*l| assert_equal([], r); assert_equal([1], l)} f.call([], *[1]) - + f = lambda{|x| x} - 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(42, f.call(42)) + assert_equal([42], f.call([42])) + assert_equal([[42]], f.call([[42]])) + assert_equal([42,55], f.call([42,55])) + f = lambda{|x,| x} - 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(42, f.call(42)) + assert_equal([42], f.call([42])) + assert_equal([[42]], f.call([[42]])) + assert_equal([42,55], f.call([42,55])) + f = lambda{|*x| x} - 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]) + assert_equal([42], f.call(42)) + assert_equal([[42]], f.call([42])) + assert_equal([[[42]]], f.call([[42]])) + assert_equal([[42,55]], f.call([42,55])) + assert_equal([42,55], f.call(42,55)) end def test_multi a,=*[1] - assert_equal(a, 1) + assert_equal(1, a) a,=*[[1]] - assert_equal(a, [1]) + assert_equal([1], a) a,=*[[[1]]] - assert_equal(a, [[1]]) - + assert_equal([[1]], a) + x, (y, z) = 1, 2, 3 assert_equal([1,2,nil], [x,y,z]) x, (y, z) = 1, [2,3] @@ -283,87 +283,87 @@ class TestAssignment < Test::Unit::TestCase end def test_break - 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,[]]) + a = loop do break; end; assert_nil(a) + a = loop do break nil; end; assert_nil(a) + a = loop do break 1; end; assert_equal(1, a) + a = loop do break []; end; assert_equal([], a) + a = loop do break [1]; end; assert_equal([1], a) + a = loop do break [nil]; end; assert_equal([nil], a) + a = loop do break [[]]; end; assert_equal([[]], a) + a = loop do break [*[]]; end; assert_equal([], a) + a = loop do break [*[1]]; end; assert_equal([1], a) + a = loop do break [*[1,2]]; end; assert_equal([1,2], a) + + a = loop do break *nil; end; assert_nil(a) + a = loop do break *1; end; assert_equal(1, a) + a = loop do break *[]; end; assert_nil(a) + a = loop do break *[1]; end; assert_equal(1, a) + a = loop do break *[nil]; end; assert_nil(a) + a = loop do break *[[]]; end; assert_equal([], a) + a = loop do break *[*[]]; end; assert_nil(a) + a = loop do break *[*[1]]; end; assert_equal(1, a) + a = loop do break *[*[1,2]]; end; assert_equal([1,2], a) + + *a = loop do break; end; assert_equal([nil], a) + *a = loop do break nil; end; assert_equal([nil], a) + *a = loop do break 1; end; assert_equal([1], a) + *a = loop do break []; end; assert_equal([[]], a) + *a = loop do break [1]; end; assert_equal([[1]], a) + *a = loop do break [nil]; end; assert_equal([[nil]], a) + *a = loop do break [[]]; end; assert_equal([[[]]], a) + *a = loop do break [1,2]; end; assert_equal([[1,2]], a) + *a = loop do break [*[]]; end; assert_equal([[]], a) + *a = loop do break [*[1]]; end; assert_equal([[1]], a) + *a = loop do break [*[1,2]]; end; assert_equal([[1,2]], a) + + *a = loop do break *nil; end; assert_equal([nil], a) + *a = loop do break *1; end; assert_equal([1], a) + *a = loop do break *[]; end; assert_equal([nil], a) + *a = loop do break *[1]; end; assert_equal([1], a) + *a = loop do break *[nil]; end; assert_equal([nil], a) + *a = loop do break *[[]]; end; assert_equal([[]], a) + *a = loop do break *[1,2]; end; assert_equal([[1,2]], a) + *a = loop do break *[*[]]; end; assert_equal([nil], a) + *a = loop do break *[*[1]]; end; assert_equal([1], a) + *a = loop do break *[*[1,2]]; end; assert_equal([[1,2]], a) + + *a = *loop do break *nil; end; assert_equal([nil], a) + *a = *loop do break *1; end; assert_equal([1], a) + *a = *loop do break *[]; end; assert_equal([nil], a) + *a = *loop do break *[1]; end; assert_equal([1], a) + *a = *loop do break *[nil]; end; assert_equal([nil], a) + *a = *loop do break *[[]]; end; assert_equal([], a) + *a = *loop do break *[1,2]; end; assert_equal([1,2], a) + *a = *loop do break *[*[]]; end; assert_equal([nil], a) + *a = *loop do break *[*[1]]; end; assert_equal([1], a) + *a = *loop do break *[*[1,2]]; end; assert_equal([1,2], a) + + a,b,*c = loop do break; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break nil; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break 1; end; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = loop do break []; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break [1]; end; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = loop do break [nil]; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break [[]]; end; assert_equal([[],nil,[]], [a,b,c]) + a,b,*c = loop do break [1,2]; end; assert_equal([1,2,[]], [a,b,c]) + a,b,*c = loop do break [*[]]; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break [*[1]]; end; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = loop do break [*[1,2]]; end; assert_equal([1,2,[]], [a,b,c]) + + a,b,*c = loop do break *nil; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break *1; end; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = loop do break *[]; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break *[1]; end; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = loop do break *[nil]; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break *[[]]; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break *[1,2]; end; assert_equal([1,2,[]], [a,b,c]) + a,b,*c = loop do break *[*[]]; end; assert_equal([nil,nil,[]], [a,b,c]) + a,b,*c = loop do break *[*[1]]; end; assert_equal([1,nil,[]], [a,b,c]) + a,b,*c = loop do break *[*[1,2]]; end; assert_equal([1,2,[]], [a,b,c]) end def test_next - def r(val); a = yield(); assert_equal(a, val); end + def r(val); a = yield(); assert_equal(val, a); end r(nil){next} r(nil){next nil} r(1){next 1} @@ -374,7 +374,7 @@ class TestAssignment < Test::Unit::TestCase r([]){next [*[]]} r([1]){next [*[1]]} r([1,2]){next [*[1,2]]} - + r(nil){next *nil} r(1){next *1} r(nil){next *[]} @@ -384,8 +384,8 @@ class TestAssignment < Test::Unit::TestCase r(nil){next *[*[]]} r(1){next *[*[1]]} r([1,2]){next *[*[1,2]]} - - def r(val); *a = yield(); assert_equal(a, val); end + + def r(val); *a = yield(); assert_equal(val, a); end r([nil]){next} r([nil]){next nil} r([1]){next 1} @@ -397,8 +397,8 @@ class TestAssignment < Test::Unit::TestCase r([[]]){next [*[]]} r([[1]]){next [*[1]]} r([[1,2]]){next [*[1,2]]} - - def r(val); *a = *yield(); assert_equal(a, val); end + + def r(val); *a = *yield(); assert_equal(val, a); end r([nil]){next *nil} r([1]){next *1} r([nil]){next *[]} @@ -409,8 +409,8 @@ class TestAssignment < Test::Unit::TestCase r([nil]){next *[*[]]} r([1]){next *[*[1]]} r([1,2]){next *[*[1,2]]} - - def r(val); a,b,*c = yield(); assert_equal([a,b,c], val); end + + def r(val); a,b,*c = yield(); assert_equal(val, [a,b,c]); end r([nil,nil,[]]){next} r([nil,nil,[]]){next nil} r([1,nil,[]]){next 1} @@ -422,8 +422,8 @@ class TestAssignment < Test::Unit::TestCase r([nil,nil,[]]){next [*[]]} r([1,nil,[]]){next [*[1]]} r([1,2,[]]){next [*[1,2]]} - - def r(val); a,b,*c = *yield(); assert_equal([a,b,c], val); end + + def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end r([nil,nil,[]]){next *nil} r([1,nil,[]]){next *1} r([nil,nil,[]]){next *[]} @@ -439,31 +439,31 @@ class TestAssignment < Test::Unit::TestCase def test_assign2 a = nil assert(defined?(a)) - assert_equal(a, nil) - + assert_nil(a) + # multiple asignment a, b = 1, 2 assert(a == 1 && b == 2) - + a, b = b, a assert(a == 2 && b == 1) - + a, = 1,2 - assert_equal(a, 1) - + assert_equal(1, a) + a, *b = 1, 2, 3 assert(a == 1 && b == [2, 3]) - + a, (b, c), d = 1, [2, 3], 4 assert(a == 1 && b == 2 && c == 3 && d == 4) - + *a = 1, 2, 3 - assert_equal(a, [1, 2, 3]) - + assert_equal([1, 2, 3], a) + *a = 4 - assert_equal(a, [4]) - + assert_equal([4], a) + *a = nil - assert_equal(a, [nil]) + assert_equal([nil], a) end end diff --git a/test/ruby/test_bignum.rb b/test/ruby/test_bignum.rb index 78e3a38279..0ba2397c54 100644 --- a/test/ruby/test_bignum.rb +++ b/test/ruby/test_bignum.rb @@ -19,47 +19,36 @@ class TestBignum < Test::Unit::TestCase assert_equal($x, fact(40)) assert($x < $x+2) assert($x > $x-2) - assert_equal($x, 815915283247897734345611269596115894272000000000) - assert_not_equal($x, 815915283247897734345611269596115894272000000001) - assert_equal($x+1, 815915283247897734345611269596115894272000000001) - assert_equal($x/fact(20), 335367096786357081410764800000) + assert_equal(815915283247897734345611269596115894272000000000, $x) + assert_not_equal(815915283247897734345611269596115894272000000001, $x) + assert_equal(815915283247897734345611269596115894272000000001, $x+1) + assert_equal(335367096786357081410764800000, $x/fact(20)) $x = -$x - assert_equal($x, -815915283247897734345611269596115894272000000000) + assert_equal(-815915283247897734345611269596115894272000000000, $x) assert_equal(2-(2**32), -(2**32-2)) assert_equal(2**32 - 5, (2**32-3)-2) - $good = true; for i in 1000..1014 - $good = false if ((1<> 1 - $good = false if (n1 != n2) + assert_equal(n1, n2) end - assert($good) - - $good = true; + for i in 4000..4096 n1 = 1 << i; - if (n1**2-1) / (n1+1) != (n1-1) - p i - $good = false - end + assert_equal(n1-1, (n1**2-1) / (n1+1)) end - assert($good) end def test_calc @@ -73,14 +62,14 @@ class TestBignum < Test::Unit::TestCase assert_equal(7, a.remainder(-b)) assert_equal(-7, (-a).remainder(b)) assert_equal(-7, (-a).remainder(-b)) - - assert_equal(10**40+10**20, 10000000000000000000100000000000000000000) - assert_equal(10**40/10**20, 100000000000000000000) - + + assert_equal(10000000000000000000100000000000000000000, 10**40+10**20) + assert_equal(100000000000000000000, 10**40/10**20) + a = 677330545177305025495135714080 b = 14269972710765292560 - assert_equal(a % b, 0) - assert_equal(-a % b, 0) + assert_equal(0, a % b) + assert_equal(0, -a % b) end def test_shift @@ -88,12 +77,12 @@ class TestBignum < Test::Unit::TestCase b = a / (2 ** 32) c = a >> 32 assert_equal(b, c) - + b = a * (2 ** 32) c = a << 32 assert_equal(b, c) end - + shift_test(-4518325415524767873) shift_test(-0xfffffffffffffffff) end diff --git a/test/ruby/test_call.rb b/test/ruby/test_call.rb index c92b8b0ae9..7694d5196c 100644 --- a/test/ruby/test_call.rb +++ b/test/ruby/test_call.rb @@ -10,23 +10,12 @@ class TestCall < Test::Unit::TestCase end def test_call - begin - aaa() # need at least 1 arg - assert(false) - rescue - assert(true) - end - - begin - aaa # no arg given (exception raised) - assert(false) - rescue - assert(true) - end - - 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]) + assert_raises(ArgumentError) {aaa()} + assert_raises(ArgumentError) {aaa} + + assert_equal([1, 100], aaa(1)) + assert_equal([1, 2], aaa(1, 2)) + assert_equal([1, 2, 3, 4], aaa(1, 2, 3, 4)) + assert_equal([1, 2, 3, 4], aaa(1, *[2, 3, 4])) end end diff --git a/test/ruby/test_case.rb b/test/ruby/test_case.rb index 325d123dc9..5046193662 100644 --- a/test/ruby/test_case.rb +++ b/test/ruby/test_case.rb @@ -10,28 +10,28 @@ class TestCase < Test::Unit::TestCase when 5 assert(true) end - + case 5 when 5 assert(true) when 1..10 assert(false) end - + case 5 when 1..10 assert(true) else assert(false) end - + case 5 when 5 assert(true) else assert(false) end - + case "foobar" when /^f.*r$/ assert(true) diff --git a/test/ruby/test_clone.rb b/test/ruby/test_clone.rb index 64dba41c21..612636c046 100644 --- a/test/ruby/test_clone.rb +++ b/test/ruby/test_clone.rb @@ -8,7 +8,7 @@ class TestClone < Test::Unit::TestCase module M003; include M002; end module M002; include M001; end module M003; include M002; end - + def test_clone foo = Object.new def foo.test @@ -18,18 +18,13 @@ class TestClone < Test::Unit::TestCase def bar.test2 "test2" end - - assert_equal(bar.test2, "test2") - assert_equal(bar.test, "test") - assert_equal(foo.test, "test") - - begin - foo.test2 - assert false - rescue NoMethodError - assert true - end - - assert_equal(M003.ancestors, [M003, M002, M001]) + + assert_equal("test2", bar.test2) + assert_equal("test", bar.test) + assert_equal("test", foo.test) + + assert_raises(NoMethodError) {foo.test2} + + assert_equal([M003, M002, M001], M003.ancestors) end end diff --git a/test/ruby/test_condition.rb b/test/ruby/test_condition.rb index 303521f95f..2ef2e0db30 100644 --- a/test/ruby/test_condition.rb +++ b/test/ruby/test_condition.rb @@ -8,11 +8,11 @@ class TestCondition < Test::Unit::TestCase def test_condition $x = '0'; - + $x == $x && assert(true) $x != $x && assert(false) $x == $x || assert(false) $x != $x || assert(true) - + end end diff --git a/test/ruby/test_const.rb b/test/ruby/test_const.rb index 9ad5bd4338..dfacceb629 100644 --- a/test/ruby/test_const.rb +++ b/test/ruby/test_const.rb @@ -5,31 +5,31 @@ $KCODE = 'none' class TestConst < Test::Unit::TestCase TEST1 = 1 TEST2 = 2 - + module Const TEST3 = 3 TEST4 = 4 end - + module Const2 TEST3 = 6 TEST4 = 8 end - + def test_const self.class.class_eval { include Const } - assert_equal([TEST1,TEST2,TEST3,TEST4], [1,2,3,4]) - + assert_equal([1,2,3,4], [TEST1,TEST2,TEST3,TEST4]) + self.class.class_eval { include Const2 } STDERR.print "intentionally redefines TEST3, TEST4\n" if $VERBOSE - assert_equal([TEST1,TEST2,TEST3,TEST4], [1,2,6,8]) - - assert_equal((String <=> Object), -1) - assert_equal((Object <=> String), 1) - assert_equal((Array <=> String), nil) + assert_equal([1,2,6,8], [TEST1,TEST2,TEST3,TEST4]) + + assert_equal(-1, (String <=> Object)) + assert_equal(1, (Object <=> String)) + assert_equal(nil, (Array <=> String)) end end diff --git a/test/ruby/test_defined.rb b/test/ruby/test_defined.rb index 999457f917..e53778f75f 100644 --- a/test/ruby/test_defined.rb +++ b/test/ruby/test_defined.rb @@ -22,20 +22,20 @@ class TestDefined < Test::Unit::TestCase $x = nil assert(defined?($x)) # global variable - assert_equal(defined?($x), 'global-variable')# returns description - + assert_equal('global-variable', defined?($x))# returns description + foo=5 assert(defined?(foo)) # local variable - + assert(defined?(::Array)) # constant !! Array -> ::Array assert(defined?(Object.new)) # method assert(!defined?(Object.print)) # private method assert(defined?(1 == 2)) # operator expression - + f = Foo.new - assert_equal(defined?(f.foo), nil) + assert_nil(defined?(f.foo)) f.bar(f) { |v| assert(v) } - + assert(defined_test) # not iterator assert(!defined_test{}) # called as iterator end diff --git a/test/ruby/test_eval.rb b/test/ruby/test_eval.rb index 35cbbfd7d6..c64741df33 100644 --- a/test/ruby/test_eval.rb +++ b/test/ruby/test_eval.rb @@ -13,35 +13,35 @@ class TestEval < Test::Unit::TestCase end def test_eval - assert_equal(eval(""), nil) + assert_nil(eval("")) $bad=false eval 'while false; $bad = true; print "foo\n" end' assert(!$bad) - + assert(eval('TRUE')) assert(eval('true')) assert(!eval('NIL')) assert(!eval('nil')) assert(!eval('FALSE')) assert(!eval('false')) - + $foo = 'assert(true)' begin eval $foo rescue assert(false) end - - assert_equal(eval("$foo"), 'assert(true)') - assert_equal(eval("true"), true) + + assert_equal('assert(true)', eval("$foo")) + assert_equal(true, eval("true")) i = 5 assert(eval("i == 5")) - assert_equal(eval("i"), 5) + assert_equal(5, eval("i")) assert(eval("defined? i")) - + $x = test_ev - assert_equal(eval("local1", $x), "local1") # normal local var - assert_equal(eval("local2", $x), "local2") # nested local var + assert_equal("local1", eval("local1", $x)) # normal local var + assert_equal("local2", eval("local2", $x)) # nested local var $bad = true begin p eval("local1") @@ -49,7 +49,7 @@ class TestEval < Test::Unit::TestCase $bad = false end assert(!$bad) - + # !! use class_eval to avoid nested definition self.class.class_eval %q( module EvTest @@ -58,8 +58,8 @@ class TestEval < Test::Unit::TestCase $x = binding end ) - assert_equal(eval("EVTEST1", $x), 25) # constant in module - assert_equal(eval("evtest2", $x), 125) # local var in module + assert_equal(25, eval("EVTEST1", $x)) # constant in module + assert_equal(125, eval("evtest2", $x)) # local var in module $bad = true begin eval("EVTEST1") @@ -67,58 +67,58 @@ class TestEval < Test::Unit::TestCase $bad = false end assert(!$bad) - + x = proc{} eval "i4 = 1", x - assert_equal(eval("i4", x), 1) + assert_equal(1, eval("i4", x)) x = proc{proc{}}.call eval "i4 = 22", x - assert_equal(eval("i4", x), 22) + assert_equal(22, eval("i4", x)) $x = [] x = proc{proc{}}.call eval "(0..9).each{|i5| $x[i5] = proc{i5*2}}", x - assert_equal($x[4].call, 8) - + assert_equal(8, $x[4].call) + x = binding eval "i = 1", x - assert_equal(eval("i", x), 1) + assert_equal(1, eval("i", x)) x = proc{binding}.call eval "i = 22", x - assert_equal(eval("i", x), 22) + assert_equal(22, eval("i", x)) $x = [] x = proc{binding}.call eval "(0..9).each{|i5| $x[i5] = proc{i5*2}}", x - assert_equal($x[4].call, 8) + assert_equal(8, $x[4].call) x = proc{binding}.call eval "for i6 in 1..1; j6=i6; end", x assert(eval("defined? i6", x)) assert(eval("defined? j6", x)) - + proc { p = binding eval "foo11 = 1", p foo22 = 5 proc{foo11=22}.call proc{foo22=55}.call - assert_equal(eval("foo11", p), eval("foo11")) - assert_equal(eval("foo11"), 1) - assert_equal(eval("foo22", p), eval("foo22")) - assert_equal(eval("foo22"), 55) + assert_equal(eval("foo11"), eval("foo11", p)) + assert_equal(1, eval("foo11")) + assert_equal(eval("foo22"), eval("foo22", p)) + assert_equal(55, eval("foo22")) }.call - + p1 = proc{i7 = 0; proc{i7}}.call - assert_equal(p1.call, 0) + assert_equal(0, p1.call) eval "i7=5", p1 - assert_equal(p1.call, 5) + assert_equal(5, p1.call) assert(!defined?(i7)) - + p1 = proc{i7 = 0; proc{i7}}.call i7 = nil - assert_equal(p1.call, 0) + assert_equal(0, p1.call) eval "i7=1", p1 - assert_equal(p1.call, 1) + assert_equal(1, p1.call) eval "i7=5", p1 - assert_equal(p1.call, 5) - assert_equal(i7, nil) + assert_equal(5, p1.call) + assert_nil(i7) end end diff --git a/test/ruby/test_exception.rb b/test/ruby/test_exception.rb index e22b3b37bb..0e120a9b71 100644 --- a/test/ruby/test_exception.rb +++ b/test/ruby/test_exception.rb @@ -10,7 +10,7 @@ class TestException < Test::Unit::TestCase rescue assert(true) end - + $bad = true begin raise "this must be handled no.2" @@ -22,32 +22,33 @@ class TestException < Test::Unit::TestCase end end assert(true) - + # exception in rescue clause $string = "this must be handled no.3" - begin + e = assert_raises(RuntimeError) do begin raise "exception in rescue clause" - rescue + rescue raise $string end assert(false) - rescue - assert(true) if $! == $string end - + assert_equal($string, e.message) + # exception in ensure clause - begin + $string = "exception in ensure clause" + e = assert_raises(RuntimeError) do begin raise "this must be handled no.4" - ensure + ensure + assert_instance_of(RuntimeError, $!) + assert_equal("this must be handled no.4", $!.message) raise "exception in ensure clause" end assert(false) - rescue - assert(true) end - + assert_equal($string, e.message) + $bad = true begin begin @@ -58,7 +59,7 @@ class TestException < Test::Unit::TestCase rescue end assert(!$bad) - + $bad = true begin begin @@ -69,7 +70,7 @@ class TestException < Test::Unit::TestCase rescue end assert(!$bad) - + $bad = true while true begin @@ -79,7 +80,7 @@ class TestException < Test::Unit::TestCase end end assert(!$bad) - + assert(catch(:foo) { loop do loop do @@ -91,6 +92,6 @@ class TestException < Test::Unit::TestCase end false }) - + end end diff --git a/test/ruby/test_float.rb b/test/ruby/test_float.rb index e639909761..dba3f6b5a9 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_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_equal(2, 2.6.floor) + assert_equal(-3, (-2.6).floor) + assert_equal(3, 2.6.ceil) + assert_equal(-2, (-2.6).ceil) + assert_equal(2, 2.6.truncate) + assert_equal(-2, (-2.6).truncate) + assert_equal(3, 2.6.round) + assert_equal(-2, (-2.4).truncate) 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_equal((self < v), false) - assert_equal((self > v), false) - assert_equal((self <= v), false) - assert_equal((self >= v), false) + assert_equal(false, (self < v)) + assert_equal(false, (self > v)) + assert_equal(false, (self <= v)) + assert_equal(false, (self >= v)) end nan.test(nan) nan.test(0) @@ -36,7 +36,7 @@ class TestFloat < Test::Unit::TestCase nan.test(-0.001); nan.test(1.0/0); nan.test(-1.0/0); - + #s = "3.7517675036461267e+17" #assert(s == sprintf("%.16e", s.to_f)) f = 3.7517675036461267e+17 diff --git a/test/ruby/test_gc.rb b/test/ruby/test_gc.rb index b55c391802..5b824309ac 100644 --- a/test/ruby/test_gc.rb +++ b/test/ruby/test_gc.rb @@ -10,14 +10,11 @@ class TestGc < Test::Unit::TestCase end def test_gc - begin + assert_nothing_raised do 1.upto(10000) { tmp = [0,1,2,3,4,5,6,7,8,9] } tmp = nil - assert true - rescue - assert false end l=nil 100000.times { diff --git a/test/ruby/test_hash.rb b/test/ruby/test_hash.rb index 562ac93dfc..22c694ef1f 100644 --- a/test/ruby/test_hash.rb +++ b/test/ruby/test_hash.rb @@ -6,10 +6,10 @@ class TestHash < Test::Unit::TestCase def test_hash $x = {1=>2, 2=>4, 3=>6} $y = {1, 2, 2, 4, 3, 6} - - assert_equal($x[1], 2) - - assert(begin + + assert_equal(2, $x[1]) + + assert(begin for k,v in $y raise if k*2 != v end @@ -17,60 +17,60 @@ class TestHash < Test::Unit::TestCase rescue false end) - - assert_equal($x.length, 3) + + assert_equal(3, $x.length) assert($x.has_key?(1)) assert($x.has_value?(4)) - assert_equal($x.values_at(2,3), [4,6]) - assert_equal($x, {1=>2, 2=>4, 3=>6}) - + assert_equal([4,6], $x.values_at(2,3)) + assert_equal({1=>2, 2=>4, 3=>6}, $x) + $z = $y.keys.join(":") - assert_equal($z, "1:2:3") - + assert_equal("1:2:3", $z) + $z = $y.values.join(":") - assert_equal($z, "2:4:6") + assert_equal("2:4:6", $z) assert_equal($x, $y) - + $y.shift - assert_equal($y.length, 2) - + assert_equal(2, $y.length) + $z = [1,2] $y[$z] = 256 - assert_equal($y[$z], 256) - + assert_equal(256, $y[$z]) + $x = Hash.new(0) $x[1] = 1 - assert_equal($x[1], 1) - assert_equal($x[2], 0) - + assert_equal(1, $x[1]) + assert_equal(0, $x[2]) + $x = Hash.new([]) - assert_equal($x[22], []) + assert_equal([], $x[22]) assert($x[22].equal?($x[22])) - + $x = Hash.new{[]} - assert_equal($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_equal($x[22], 44) - assert_equal($z, 22) + assert_equal(44, $x[22]) + assert_equal(22, $z) $z = 0 - assert_equal($x[22], 44) - assert_equal($z, 0) + assert_equal(44, $x[22]) + assert_equal(0, $z) $x.default = 5 - assert_equal($x[23], 5) - + assert_equal(5, $x[23]) + $x = Hash.new def $x.default(k) $z = k self[k] = k*2 end $z = 0 - assert_equal($x[22], 44) - assert_equal($z, 22) + assert_equal(44, $x[22]) + assert_equal(22, $z) $z = 0 - assert_equal($x[22], 44) - assert_equal($z, 0) + assert_equal(44, $x[22]) + assert_equal(0, $z) end end diff --git a/test/ruby/test_iterator.rb b/test/ruby/test_iterator.rb index 2c367d22dc..296efaf269 100644 --- a/test/ruby/test_iterator.rb +++ b/test/ruby/test_iterator.rb @@ -182,8 +182,8 @@ class TestIterator < Test::Unit::TestCase def test_block_in_arg assert(m1{p 'test'}) assert(m2{p 'test'}) - assert(!m1) - assert(!m2) + assert(!m1()) + assert(!m2()) end class C @@ -356,6 +356,6 @@ class TestIterator < Test::Unit::TestCase end def test_iter4 - ITER_TEST4.new.foo(44){55} + ITER_TEST4.new.foo(44){55} end end diff --git a/test/ruby/test_marshal.rb b/test/ruby/test_marshal.rb index 862b7e2006..30b52f4697 100644 --- a/test/ruby/test_marshal.rb +++ b/test/ruby/test_marshal.rb @@ -20,7 +20,7 @@ class TestMarshal < Test::Unit::TestCase $y = Marshal.dump($x) assert_equal($x, Marshal.load($y)) - assert_equal(Marshal.load(Marshal.dump(StrClone.new("abc"))).class, StrClone) + assert_instance_of(StrClone, Marshal.load(Marshal.dump(StrClone.new("abc")))) [[1,2,3,4], [81, 2, 118, 3146]].each { |w,x,y,z| a = (x.to_f + y.to_f / z.to_f) * Math.exp(w.to_f / (x.to_f + y.to_f / z.to_f)) diff --git a/test/ruby/test_math.rb b/test/ruby/test_math.rb index 58041eaa35..c5ddbbdb05 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_equal(Math.sqrt(4), 2) - + assert_equal(2, Math.sqrt(4)) + self.class.class_eval { include Math } - assert_equal(sqrt(4), 2) + assert_equal(2, sqrt(4)) end end diff --git a/test/ruby/test_pack.rb b/test/ruby/test_pack.rb index 4bb17993f5..4132c89a61 100644 --- a/test/ruby/test_pack.rb +++ b/test/ruby/test_pack.rb @@ -10,12 +10,12 @@ class TestPack < Test::Unit::TestCase ary = [1,-100,127,128,32767,987.654321098 / 100.0,12345,123456,-32767,-123456,"abcdef"] $x = ary.pack($format) ary2 = $x.unpack($format) - + assert_equal(ary.length, ary2.length) assert_equal(ary.join(':'), ary2.join(':')) assert($x =~ /def/) - + $x = [-1073741825] - assert_equal($x.pack("q").unpack("q"), $x) + assert_equal($x, $x.pack("q").unpack("q")) end end diff --git a/test/ruby/test_path.rb b/test/ruby/test_path.rb index 9faee72add..55452beb70 100644 --- a/test/ruby/test_path.rb +++ b/test/ruby/test_path.rb @@ -4,45 +4,45 @@ $KCODE = 'none' class TestPath < Test::Unit::TestCase def test_path - 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") + assert_equal("a", File.basename("a")) + assert_equal("b", File.basename("a/b")) + assert_equal("b", File.basename("a/b/")) + assert_equal("/", File.basename("/")) + assert_equal("/", File.basename("//")) + assert_equal("/", File.basename("///")) + assert_equal("b", File.basename("a/b////")) + assert_equal("a", File.basename("a.rb", ".rb")) + assert_equal("a", File.basename("a.rb///", ".rb")) + assert_equal("a", File.basename("a.rb///", ".*")) + assert_equal("a.rb", File.basename("a.rb///", ".c")) + assert_equal(".", File.dirname("a")) + assert_equal("/", File.dirname("/")) + assert_equal("/", File.dirname("/a")) + assert_equal("a", File.dirname("a/b")) + assert_equal("a/b", File.dirname("a/b/c")) + assert_equal("/a/b", File.dirname("/a/b/c")) + assert_equal("/a", File.dirname("/a/b/")) + assert_equal("/a", File.dirname("/a/b///")) case Dir.pwd when %r'\A\w:' - assert(/\A\w:\/\z/ =~ File.expand_path(".", "/")) - assert(/\A\w:\/a\z/ =~ File.expand_path("a", "/")) + assert_match(/\A\w:\/\z/, File.expand_path(".", "/")) + assert_match(/\A\w:\/a\z/, File.expand_path("a", "/")) dosish = true when %r'\A//' - assert(%r'\A//[^/]+/[^/]+\z' =~ File.expand_path(".", "/")) - assert(%r'\A//[^/]+/[^/]+/a\z' =~ File.expand_path(".", "/")) + assert_match(%r'\A//[^/]+/[^/]+\z', File.expand_path(".", "/")) + assert_match(%r'\A//[^/]+/[^/]+/a\z', File.expand_path(".", "/")) dosish = true else - assert_equal(File.expand_path(".", "/"), "/") - assert_equal(File.expand_path("sub", "/"), "/sub") + assert_equal("/", File.expand_path(".", "/")) + assert_equal("/sub", File.expand_path("sub", "/")) end if dosish - 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") + assert_equal("//machine/share", File.expand_path("/", "//machine/share/sub")) + assert_equal("//machine/share/dir", File.expand_path("/dir", "//machine/share/sub")) + assert_equal("z:/", File.expand_path("/", "z:/sub")) + assert_equal("z:/dir", File.expand_path("/dir", "z:/sub")) end - assert_equal(File.expand_path(".", "//"), "//") - assert_equal(File.expand_path("sub", "//"), "//sub") + assert_equal("//", File.expand_path(".", "//")) + assert_equal("//sub", File.expand_path("sub", "//")) end end diff --git a/test/ruby/test_proc.rb b/test/ruby/test_proc.rb index 893bc3f1a1..2076f7bbac 100644 --- a/test/ruby/test_proc.rb +++ b/test/ruby/test_proc.rb @@ -5,13 +5,13 @@ $KCODE = 'none' class TestProc < Test::Unit::TestCase def test_proc $proc = proc{|i| i} - assert_equal($proc.call(2), 2) - assert_equal($proc.call(3), 3) - + assert_equal(2, $proc.call(2)) + assert_equal(3, $proc.call(3)) + $proc = proc{|i| i*2} - assert_equal($proc.call(2), 4) - assert_equal($proc.call(3), 6) - + assert_equal(4, $proc.call(2)) + assert_equal(6, $proc.call(3)) + proc{ iii=5 # nested local variable $proc = proc{|i| @@ -24,11 +24,11 @@ class TestProc < Test::Unit::TestCase assert(defined?(iii)) }.call assert(!defined?(iii)) # out of scope - + loop{iii=5; assert(eval("defined? iii")); break} loop { iii = 10 - def dyna_var_check + def self.dyna_var_check loop { assert(!defined?(iii)) break @@ -40,6 +40,6 @@ class TestProc < Test::Unit::TestCase $x=0 $proc.call(5) $proc2.call - assert_equal($x, 5) + assert_equal(5, $x) end end diff --git a/test/ruby/test_signal.rb b/test/ruby/test_signal.rb index eabeedc38a..61240cd65d 100644 --- a/test/ruby/test_signal.rb +++ b/test/ruby/test_signal.rb @@ -9,18 +9,16 @@ class TestSignal < Test::Unit::TestCase trap "SIGINT", proc{|sig| $x = 2} Process.kill "SIGINT", $$ sleep 0.1 - assert_equal($x, 2) - + assert_equal(2, $x) + trap "SIGINT", proc{raise "Interrupt"} - - x = false - begin + + x = assert_raises(RuntimeError) do Process.kill "SIGINT", $$ sleep 0.1 - rescue - x = $! end - assert(x && /Interrupt/ =~ x.message) + assert(x) + assert_match(/Interrupt/, x.message) end end end diff --git a/test/ruby/test_stringchar.rb b/test/ruby/test_stringchar.rb index 78ec39d56c..9e22bb35a0 100644 --- a/test/ruby/test_stringchar.rb +++ b/test/ruby/test_stringchar.rb @@ -8,78 +8,78 @@ class TestStringchar < Test::Unit::TestCase assert("abcd" =~ /abcd/) assert("abcd" === "abcd") # compile time string concatenation - assert_equal("ab" "cd", "abcd") - assert_equal("#{22}aa" "cd#{44}", "22aacd44") - assert_equal("#{22}aa" "cd#{44}" "55" "#{66}", "22aacd445566") + assert_equal("abcd", "ab" "cd") + assert_equal("22aacd44", "#{22}aa" "cd#{44}") + assert_equal("22aacd445566", "#{22}aa" "cd#{44}" "55" "#{66}") assert("abc" !~ /^$/) assert("abc\n" !~ /^$/) assert("abc" !~ /^d*$/) - assert_equal(("abc" =~ /d*$/), 3) + assert_equal(3, ("abc" =~ /d*$/)) assert("" =~ /^$/) assert("\n" =~ /^$/) assert("a\n\n" =~ /^$/) - assert("abcabc" =~ /.*a/ && $& == "abca") - assert("abcabc" =~ /.*c/ && $& == "abcabc") - assert("abcabc" =~ /.*?a/ && $& == "a") - assert("abcabc" =~ /.*?c/ && $& == "abc") - assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n" && $& == "a\nb") - - assert(/^(ab+)+b/ =~ "ababb" && $& == "ababb") - assert(/^(?:ab+)+b/ =~ "ababb" && $& == "ababb") - assert(/^(ab+)+/ =~ "ababb" && $& == "ababb") - assert(/^(?:ab+)+/ =~ "ababb" && $& == "ababb") - - assert(/(\s+\d+){2}/ =~ " 1 2" && $& == " 1 2") - assert(/(?:\s+\d+){2}/ =~ " 1 2" && $& == " 1 2") - + assert("abcabc" =~ /.*a/); assert_equal("abca", $&) + assert("abcabc" =~ /.*c/); assert_equal("abcabc", $&) + assert("abcabc" =~ /.*?a/); assert_equal("a", $&) + assert("abcabc" =~ /.*?c/); assert_equal("abc", $&) + assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n"); assert_equal("a\nb", $&) + + assert(/^(ab+)+b/ =~ "ababb"); assert_equal("ababb", $&) + assert(/^(?:ab+)+b/ =~ "ababb"); assert_equal("ababb", $&) + assert(/^(ab+)+/ =~ "ababb"); assert_equal("ababb", $&) + assert(/^(?:ab+)+/ =~ "ababb"); assert_equal("ababb", $&) + + assert(/(\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&) + assert(/(?:\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&) + $x = <'), "") + assert_equal("gif", $x.sub(/.*\.([^\.]+)$/, '\1')) + assert_equal("b.gif", $x.sub(/.*\.([^\.]+)$/, 'b.\1')) + assert_equal("", $x.sub(/.*\.([^\.]+)$/, '\2')) + assert_equal("ab", $x.sub(/.*\.([^\.]+)$/, 'a\2b')) + assert_equal("", $x.sub(/.*\.([^\.]+)$/, '<\&>')) end def test_char # character constants(assumes ASCII) - assert_equal("a"[0], ?a) + assert_equal(?a, "a"[0]) 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") - + assert_equal(1, ?\C-a) + assert_equal(225, ?\M-a) + assert_equal(129, ?\M-\C-a) + assert_equal(?A, "a".upcase![0]) + assert_equal(?a, "A".downcase![0]) + assert_equal("ABC", "abc".tr!("a-z", "A-Z")) + assert_equal("ABC", "aabbcccc".tr_s!("a-z", "A-Z")) + assert_equal("abc", "abcc".squeeze!("a-z")) + assert_equal("ad", "abcd".delete!("bc")) + $x = "abcdef" $y = [ ?a, ?b, ?c, ?d, ?e, ?f ] $bad = false @@ -90,29 +90,29 @@ END end } assert(!$bad) - + s = "a string" s[0..s.size]="another string" - assert_equal(s, "another string") - + assert_equal("another string", s) + s = <