kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

* lib/optparse.rb (OptionParser#order, #permute, #parse): allow an

Browse source 
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
This commit is contained in:
nobu 2003-09-05 15:15:43 +00:00
parent 01e3a55648
commit 44785befea
32 changed files with 789 additions and 803 deletions
Download patch file Download diff file Expand all files Collapse all files

8
ChangeLog
View file

@ -1,3 +1,11 @@
Sat Sep 6 00:15:09 2003 Nobuyoshi Nakada <nobu@ruby-lang.org>
* 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.
Sat Sep 6 00:00:20 2003 Nobuyoshi Nakada <nobu@ruby-lang.org> Sat Sep 6 00:00:20 2003 Nobuyoshi Nakada <nobu@ruby-lang.org>
* lib/mkmf.rb (have_library, find_library): configure by library * lib/mkmf.rb (have_library, find_library): configure by library

17
lib/optparse.rb
View file

@ -801,6 +801,14 @@ Default options, which never appear in option summary.
end end
end end
def warn(mesg = $!)
super(program_name + ': ' + mesg)
end
def abort(mesg = $!)
super(program_name + ': ' + mesg)
end
=begin =begin
--- OptionParser#top --- OptionParser#top
Subject of ((<on>))/((<on_head>)), ((<accept>))/((<reject>)). Subject of ((<on>))/((<on_head>)), ((<accept>))/((<reject>)).
@ -1120,7 +1128,10 @@ Default options, which never appear in option summary.
: (({block})) : (({block}))
called with each non-option argument. called with each non-option argument.
=end #'#"#`# =end #'#"#`#
def order(*argv, &block) order!(argv, &block) end def order(*argv, &block)
argv = argv[0].dup if argv.size == 1 and Array === argv[0]
order!(argv, &block)
end
def order!(argv = ARGV, &nonopt) def order!(argv = ARGV, &nonopt)
opt, arg, sw, val, rest = nil opt, arg, sw, val, rest = nil
@ -1198,6 +1209,7 @@ Default options, which never appear in option summary.
command line arguments to be parsed. command line arguments to be parsed.
=end #'#"#`# =end #'#"#`#
def permute(*argv) def permute(*argv)
argv = argv[0].dup if argv.size == 1 and Array === argv[0]
permute!(argv) permute!(argv)
end end
@ -1223,6 +1235,7 @@ Default options, which never appear in option summary.
command line arguments to be parsed. command line arguments to be parsed.
=end #'#"#`# =end #'#"#`#
def parse(*argv) def parse(*argv)
argv = argv[0].dup if argv.size == 1 and Array === argv[0]
parse!(argv) parse!(argv)
end end
@ -1607,7 +1620,7 @@ Extends command line arguments array to parse itself.
begin begin
yield @optparse yield @optparse
rescue ParseError rescue ParseError
warn @optparse.program_name + ': ' + $! @optparse.warn $!
nil nil
end end
end end

6
test/csv/test_csv.rb
View file

@ -1139,8 +1139,10 @@ public
end end
def setBufSize(size) def setBufSize(size)
CSV::StreamBuf.module_eval('remove_const("BufSize")') CSV::StreamBuf.module_eval do
CSV::StreamBuf.module_eval("BufSize = #{ size }") remove_const(:BufSize)
const_set(:BufSize, size)
end
end end
class StrBuf < CSV::StreamBuf class StrBuf < CSV::StreamBuf

6
test/ruby/test_alias.rb
View file

@ -28,11 +28,11 @@ class TestAlias < Test::Unit::TestCase
def test_alias def test_alias
x = Alias2.new x = Alias2.new
assert_equal(x.bar, "foo") assert_equal("foo", x.bar)
assert_equal(x.baz, "foo+foo") assert_equal("foo+foo", x.baz)
# test_check for cache # test_check for cache
assert_equal(x.baz, "foo+foo") assert_equal("foo+foo", x.baz)
x = Alias3.new x = Alias3.new
assert(!x.foo) assert(!x.foo)

60
test/ruby/test_array.rb
View file

@ -4,20 +4,20 @@ $KCODE = 'none'
class TestArray < Test::Unit::TestCase class TestArray < Test::Unit::TestCase
def test_array def test_array
assert_equal([1, 2] + [3, 4], [1, 2, 3, 4]) 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], [1, 2] * 2)
assert_equal([1, 2] * ":", "1:2") assert_equal("1:2", [1, 2] * ":")
assert_equal([1, 2].hash, [1, 2].hash) assert_equal([1, 2].hash, [1, 2].hash)
assert_equal([1,2,3] & [2,3,4], [2,3]) assert_equal([2,3], [1,2,3] & [2,3,4])
assert_equal([1,2,3] | [2,3,4], [1,2,3,4]) assert_equal([1,2,3,4], [1,2,3] | [2,3,4])
assert_equal([1,2,3] - [2,3], [1]) assert_equal([1,2,3] - [2,3], [1])
$x = [0, 1, 2, 3, 4, 5] $x = [0, 1, 2, 3, 4, 5]
assert_equal($x[2], 2) assert_equal(2, $x[2])
assert_equal($x[1..3], [1, 2, 3]) assert_equal([1, 2, 3], $x[1..3])
assert_equal($x[1,3], [1, 2, 3]) assert_equal([1, 2, 3], $x[1,3])
$x[0, 2] = 10 $x[0, 2] = 10
assert($x[0] == 10 && $x[1] == 2) assert($x[0] == 10 && $x[1] == 2)
@ -30,20 +30,20 @@ class TestArray < Test::Unit::TestCase
end end
def test_array_andor def test_array_andor
assert_equal(([1,2,3]&[2,4,6]), [2]) assert_equal([2], ([1,2,3]&[2,4,6]))
assert_equal(([1,2,3]|[2,4,6]), [1,2,3,4,6]) assert_equal([1,2,3,4,6], ([1,2,3]|[2,4,6]))
end end
def test_compact def test_compact
$x = [nil, 1, nil, nil, 5, nil, nil] $x = [nil, 1, nil, nil, 5, nil, nil]
$x.compact! $x.compact!
assert_equal($x, [1, 5]) assert_equal([1, 5], $x)
end end
def test_uniq def test_uniq
$x = [1, 1, 4, 2, 5, 4, 5, 1, 2] $x = [1, 1, 4, 2, 5, 4, 5, 1, 2]
$x.uniq! $x.uniq!
assert_equal($x, [1, 4, 2, 5]) assert_equal([1, 4, 2, 5], $x)
# empty? # empty?
assert(!$x.empty?) assert(!$x.empty?)
@ -54,50 +54,50 @@ class TestArray < Test::Unit::TestCase
def test_sort def test_sort
$x = ["it", "came", "to", "pass", "that", "..."] $x = ["it", "came", "to", "pass", "that", "..."]
$x = $x.sort.join(" ") $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 = [2,5,3,1,7]
$x.sort!{|a,b| a<=>b} # sort with condition $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 $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 end
def test_split def test_split
$x = "The Boassert of Mormon" $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($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" $x = "a b c d"
assert_equal($x.split, ['a', 'b', 'c', 'd']) assert_equal(['a', 'b', 'c', 'd'], $x.split)
assert_equal($x.split(' '), ['a', 'b', 'c', 'd']) assert_equal(['a', 'b', 'c', 'd'], $x.split(' '))
end end
def test_misc def test_misc
assert(defined? "a".chomp) assert(defined? "a".chomp)
assert_equal("abc".scan(/./), ["a", "b", "c"]) assert_equal(["a", "b", "c"], "abc".scan(/./))
assert_equal("1a2b3c".scan(/(\d.)/), [["1a"], ["2b"], ["3c"]]) assert_equal([["1a"], ["2b"], ["3c"]], "1a2b3c".scan(/(\d.)/))
# non-greedy match # 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] $x = [1]
assert_equal(($x * 5).join(":"), '1:1:1:1:1') assert_equal('1:1:1:1:1', ($x * 5).join(":"))
assert_equal(($x * 1).join(":"), '1') assert_equal('1', ($x * 1).join(":"))
assert_equal(($x * 0).join(":"), '') assert_equal('', ($x * 0).join(":"))
*$x = *(1..7).to_a *$x = *(1..7).to_a
assert_equal($x.size, 7) assert_equal(7, $x.size)
assert_equal($x, [1, 2, 3, 4, 5, 6, 7]) assert_equal([1, 2, 3, 4, 5, 6, 7], $x)
$x = [1,2,3] $x = [1,2,3]
$x[1,0] = $x $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,2,3]
$x[-1,0] = $x $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 = [1,2,3]
$x.concat($x) $x.concat($x)
assert_equal($x, [1,2,3,1,2,3]) assert_equal([1,2,3,1,2,3], $x)
end end
end end

594
test/ruby/test_assignment.rb
View file

@ -5,238 +5,238 @@ $KCODE = 'none'
class TestAssignment < Test::Unit::TestCase class TestAssignment < Test::Unit::TestCase
def test_assign def test_assign
a=[]; a[0] ||= "bar"; a=[]; a[0] ||= "bar";
assert_equal(a[0], "bar") assert_equal("bar", a[0])
h={}; h["foo"] ||= "bar"; h={}; h["foo"] ||= "bar";
assert_equal(h["foo"], "bar") assert_equal("bar", h["foo"])
aa = 5 aa = 5
aa ||= 25 aa ||= 25
assert_equal(aa, 5) assert_equal(5, aa)
bb ||= 25 bb ||= 25
assert_equal(bb, 25) assert_equal(25, bb)
cc &&=33 cc &&=33
assert_equal(cc, nil) assert_nil(cc)
cc = 5 cc = 5
cc &&=44 cc &&=44
assert_equal(cc, 44) assert_equal(44, cc)
a = nil; assert_equal(a, nil) a = nil; assert_nil(a)
a = 1; assert_equal(a, 1) a = 1; assert_equal(1, a)
a = []; assert_equal(a, []) a = []; assert_equal([], a)
a = [1]; assert_equal(a, [1]) a = [1]; assert_equal([1], a)
a = [nil]; assert_equal(a, [nil]) a = [nil]; assert_equal([nil], a)
a = [[]]; assert_equal(a, [[]]) a = [[]]; assert_equal([[]], a)
a = [1,2]; assert_equal(a, [1,2]) a = [1,2]; assert_equal([1,2], a)
a = [*[]]; assert_equal(a, []) a = [*[]]; assert_equal([], a)
a = [*[1]]; assert_equal(a, [1]) a = [*[1]]; assert_equal([1], a)
a = [*[1,2]]; assert_equal(a, [1,2]) a = [*[1,2]]; assert_equal([1,2], a)
a = *nil; assert_equal(a, nil) a = *nil; assert_nil(a)
a = *1; assert_equal(a, 1) a = *1; assert_equal(1, a)
a = *[]; assert_equal(a, nil) a = *[]; assert_nil(a)
a = *[1]; assert_equal(a, 1) a = *[1]; assert_equal(1, a)
a = *[nil]; assert_equal(a, nil) a = *[nil]; assert_nil(a)
a = *[[]]; assert_equal(a, []) a = *[[]]; assert_equal([], a)
a = *[1,2]; assert_equal(a, [1,2]) a = *[1,2]; assert_equal([1,2], a)
a = *[*[]]; assert_equal(a, nil) a = *[*[]]; assert_nil(a)
a = *[*[1]]; assert_equal(a, 1) a = *[*[1]]; assert_equal(1, a)
a = *[*[1,2]]; assert_equal(a, [1,2]) a = *[*[1,2]]; assert_equal([1,2], a)
*a = nil; assert_equal(a, [nil]) *a = nil; assert_equal([nil], a)
*a = 1; assert_equal(a, [1]) *a = 1; assert_equal([1], a)
*a = []; assert_equal(a, [[]]) *a = []; assert_equal([[]], a)
*a = [1]; assert_equal(a, [[1]]) *a = [1]; assert_equal([[1]], a)
*a = [nil]; assert_equal(a, [[nil]]) *a = [nil]; assert_equal([[nil]], a)
*a = [[]]; assert_equal(a, [[[]]]) *a = [[]]; assert_equal([[[]]], a)
*a = [1,2]; assert_equal(a, [[1,2]]) *a = [1,2]; assert_equal([[1,2]], a)
*a = [*[]]; assert_equal(a, [[]]) *a = [*[]]; assert_equal([[]], a)
*a = [*[1]]; assert_equal(a, [[1]]) *a = [*[1]]; assert_equal([[1]], a)
*a = [*[1,2]]; assert_equal(a, [[1,2]]) *a = [*[1,2]]; assert_equal([[1,2]], a)
*a = *nil; assert_equal(a, [nil]) *a = *nil; assert_equal([nil], a)
*a = *1; assert_equal(a, [1]) *a = *1; assert_equal([1], a)
*a = *[]; assert_equal(a, []) *a = *[]; assert_equal([], a)
*a = *[1]; assert_equal(a, [1]) *a = *[1]; assert_equal([1], a)
*a = *[nil]; assert_equal(a, [nil]) *a = *[nil]; assert_equal([nil], a)
*a = *[[]]; assert_equal(a, [[]]) *a = *[[]]; assert_equal([[]], a)
*a = *[1,2]; assert_equal(a, [1,2]) *a = *[1,2]; assert_equal([1,2], a)
*a = *[*[]]; assert_equal(a, []) *a = *[*[]]; assert_equal([], a)
*a = *[*[1]]; assert_equal(a, [1]) *a = *[*[1]]; assert_equal([1], a)
*a = *[*[1,2]]; assert_equal(a, [1,2]) *a = *[*[1,2]]; assert_equal([1,2], a)
a,b,*c = nil; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = nil; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = 1; assert_equal([a,b,c], [1,nil,[]]) a,b,*c = 1; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = []; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = []; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = [1]; assert_equal([a,b,c], [1,nil,[]]) a,b,*c = [1]; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = [nil]; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = [nil]; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = [[]]; assert_equal([a,b,c], [[],nil,[]]) a,b,*c = [[]]; assert_equal([[],nil,[]], [a,b,c])
a,b,*c = [1,2]; assert_equal([a,b,c], [1,2,[]]) a,b,*c = [1,2]; assert_equal([1,2,[]], [a,b,c])
a,b,*c = [*[]]; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = [*[]]; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = [*[1]]; assert_equal([a,b,c], [1,nil,[]]) a,b,*c = [*[1]]; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = [*[1,2]]; assert_equal([a,b,c], [1,2,[]]) a,b,*c = [*[1,2]]; assert_equal([1,2,[]], [a,b,c])
a,b,*c = *nil; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = *nil; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = *1; assert_equal([a,b,c], [1,nil,[]]) a,b,*c = *1; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = *[]; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = *[]; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = *[1]; assert_equal([a,b,c], [1,nil,[]]) a,b,*c = *[1]; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = *[nil]; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = *[nil]; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = *[[]]; assert_equal([a,b,c], [[],nil,[]]) a,b,*c = *[[]]; assert_equal([[],nil,[]], [a,b,c])
a,b,*c = *[1,2]; assert_equal([a,b,c], [1,2,[]]) a,b,*c = *[1,2]; assert_equal([1,2,[]], [a,b,c])
a,b,*c = *[*[]]; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = *[*[]]; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = *[*[1]]; assert_equal([a,b,c], [1,nil,[]]) a,b,*c = *[*[1]]; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = *[*[1,2]]; assert_equal([a,b,c], [1,2,[]]) a,b,*c = *[*[1,2]]; assert_equal([1,2,[]], [a,b,c])
end end
def test_yield def test_yield
def f; yield nil; end; f {|a| assert_equal(a, nil)} def f; yield nil; end; f {|a| assert_nil(a)}
def f; yield 1; end; f {|a| assert_equal(a, 1)} def f; yield 1; end; f {|a| assert_equal(1, 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(a, [1])} def f; yield [1]; end; f {|a| assert_equal([1], a)}
def f; yield [nil]; end; f {|a| assert_equal(a, [nil])} 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 [*[]]; 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]]; end; f {|a| assert_equal([1], a)}
def f; yield [*[1,2]]; end; f {|a| assert_equal(a, [1,2])} def f; yield [*[1,2]]; end; f {|a| assert_equal([1,2], a)}
def f; yield *nil; end; f {|a| assert_equal(a, nil)} def f; yield *nil; end; f {|a| assert_nil(a)}
def f; yield *1; end; f {|a| assert_equal(a, 1)} def f; yield *1; end; f {|a| assert_equal(1, a)}
def f; yield *[1]; end; f {|a| assert_equal(a, 1)} def f; yield *[1]; end; f {|a| assert_equal(1, a)}
def f; yield *[nil]; end; f {|a| assert_equal(a, nil)} def f; yield *[nil]; end; f {|a| assert_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(a, 1)} def f; yield *[*[1]]; end; f {|a| assert_equal(1, a)}
def f; yield; end; f {|*a| assert_equal(a, [])} def f; yield; end; f {|*a| assert_equal([], a)}
def f; yield nil; end; f {|*a| assert_equal(a, [nil])} def f; yield nil; end; f {|*a| assert_equal([nil], a)}
def f; yield 1; end; f {|*a| assert_equal(a, [1])} def f; yield 1; end; f {|*a| assert_equal([1], 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(a, [[1]])} def f; yield [1]; end; f {|*a| assert_equal([[1]], a)}
def f; yield [nil]; end; f {|*a| assert_equal(a, [[nil]])} 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,2]; end; f {|*a| assert_equal(a, [[1,2]])} 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 [*[]]; end; f {|*a| assert_equal([[]], a)}
def f; yield [*[1]]; end; f {|*a| assert_equal(a, [[1]])} def f; yield [*[1]]; end; f {|*a| assert_equal([[1]], a)}
def f; yield [*[1,2]]; end; f {|*a| assert_equal(a, [[1,2]])} def f; yield [*[1,2]]; end; f {|*a| assert_equal([[1,2]], a)}
def f; yield *nil; end; f {|*a| assert_equal(a, [nil])} def f; yield *nil; end; f {|*a| assert_equal([nil], a)}
def f; yield *1; end; f {|*a| assert_equal(a, [1])} def f; yield *1; end; f {|*a| assert_equal([1], 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(a, [1])} def f; yield *[1]; end; f {|*a| assert_equal([1], a)}
def f; yield *[nil]; end; f {|*a| assert_equal(a, [nil])} 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 *[*[]]; 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]]; end; f {|*a| assert_equal([1], a)}
def f; yield *[*[1,2]]; end; f {|*a| assert_equal(a, [1,2])} def f; yield *[*[1,2]]; end; f {|*a| assert_equal([1,2], a)}
def f; yield; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])} 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([a,b,c], [nil,nil,[]])} 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([a,b,c], [1,nil,[]])} 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([a,b,c], [nil,nil,[]])} 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([a,b,c], [1,nil,[]])} 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([a,b,c], [nil,nil,[]])} 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([a,b,c], [[],nil,[]])} def f; yield [[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
def f; yield [*[]]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])} 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([a,b,c], [1,nil,[]])} 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([a,b,c], [1,2,[]])} 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([a,b,c], [nil,nil,[]])} 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([a,b,c], [1,nil,[]])} 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([a,b,c], [nil,nil,[]])} 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([a,b,c], [1,nil,[]])} 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([a,b,c], [nil,nil,[]])} 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([a,b,c], [[],nil,[]])} def f; yield *[[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
def f; yield *[*[]]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])} 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([a,b,c], [1,nil,[]])} 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([a,b,c], [1,2,[]])} def f; yield *[*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}
end end
def test_return def test_return
def r; return; end; a = r(); assert_equal(a, nil) def r; return; end; a = r(); assert_nil(a)
def r; return nil; end; a = r(); assert_equal(a, nil) def r; return nil; end; a = r(); assert_nil(a)
def r; return 1; end; a = r(); assert_equal(a, 1) def r; return 1; end; a = r(); assert_equal(1, 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(a, [1]) def r; return [1]; end; a = r(); assert_equal([1], a)
def r; return [nil]; end; a = r(); assert_equal(a, [nil]) 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 [*[]]; 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]]; end; a = r(); assert_equal([1], a)
def r; return [*[1,2]]; end; a = r(); assert_equal(a, [1,2]) def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a)
def r; return *nil; end; a = r(); assert_equal(a, nil) def r; return *nil; end; a = r(); assert_nil(a)
def r; return *1; end; a = r(); assert_equal(a, 1) def r; return *1; end; a = r(); assert_equal(1, a)
def r; return *[]; end; a = r(); assert_equal(a, nil) def r; return *[]; end; a = r(); assert_nil(a)
def r; return *[1]; end; a = r(); assert_equal(a, 1) def r; return *[1]; end; a = r(); assert_equal(1, a)
def r; return *[nil]; end; a = r(); assert_equal(a, nil) 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_equal([], a)
def r; return *[*[]]; end; a = r(); assert_equal(a, nil) def r; return *[*[]]; end; a = r(); assert_nil(a)
def r; return *[*[1]]; end; a = r(); assert_equal(a, 1) def r; return *[*[1]]; end; a = r(); assert_equal(1, a)
def r; return *[*[1,2]]; end; a = r(); assert_equal(a, [1,2]) def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a)
def r; return *nil; end; a = *r(); assert_equal(a, nil) def r; return *nil; end; a = *r(); assert_nil(a)
def r; return *1; end; a = *r(); assert_equal(a, 1) def r; return *1; end; a = *r(); assert_equal(1, a)
def r; return *[]; end; a = *r(); assert_equal(a, nil) def r; return *[]; end; a = *r(); assert_nil(a)
def r; return *[1]; end; a = *r(); assert_equal(a, 1) def r; return *[1]; end; a = *r(); assert_equal(1, a)
def r; return *[nil]; end; a = *r(); assert_equal(a, nil) def r; return *[nil]; end; a = *r(); assert_nil(a)
def r; return *[[]]; end; a = *r(); assert_equal(a, nil) def r; return *[[]]; end; a = *r(); assert_nil(a)
def r; return *[*[]]; end; a = *r(); assert_equal(a, nil) def r; return *[*[]]; end; a = *r(); assert_nil(a)
def r; return *[*[1]]; end; a = *r(); assert_equal(a, 1) def r; return *[*[1]]; end; a = *r(); assert_equal(1, a)
def r; return *[*[1,2]]; end; a = *r(); assert_equal(a, [1,2]) def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a)
def r; return; end; *a = r(); assert_equal(a, [nil]) def r; return; end; *a = r(); assert_equal([nil], a)
def r; return nil; end; *a = r(); assert_equal(a, [nil]) def r; return nil; end; *a = r(); assert_equal([nil], a)
def r; return 1; end; *a = r(); assert_equal(a, [1]) def r; return 1; end; *a = r(); assert_equal([1], 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(a, [[1]]) def r; return [1]; end; *a = r(); assert_equal([[1]], a)
def r; return [nil]; end; *a = r(); assert_equal(a, [[nil]]) 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,2]; end; *a = r(); assert_equal(a, [[1,2]]) 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 [*[]]; end; *a = r(); assert_equal([[]], a)
def r; return [*[1]]; end; *a = r(); assert_equal(a, [[1]]) def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a)
def r; return [*[1,2]]; end; *a = r(); assert_equal(a, [[1,2]]) def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a)
def r; return *nil; end; *a = r(); assert_equal(a, [nil]) def r; return *nil; end; *a = r(); assert_equal([nil], a)
def r; return *1; end; *a = r(); assert_equal(a, [1]) def r; return *1; end; *a = r(); assert_equal([1], a)
def r; return *[]; end; *a = r(); assert_equal(a, [nil]) def r; return *[]; end; *a = r(); assert_equal([nil], a)
def r; return *[1]; end; *a = r(); assert_equal(a, [1]) def r; return *[1]; end; *a = r(); assert_equal([1], a)
def r; return *[nil]; end; *a = r(); assert_equal(a, [nil]) 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,2]; end; *a = r(); assert_equal(a, [[1,2]]) def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a)
def r; return *[*[]]; end; *a = r(); assert_equal(a, [nil]) def r; return *[*[]]; end; *a = r(); assert_equal([nil], a)
def r; return *[*[1]]; end; *a = r(); assert_equal(a, [1]) def r; return *[*[1]]; end; *a = r(); assert_equal([1], a)
def r; return *[*[1,2]]; end; *a = r(); assert_equal(a, [[1,2]]) def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a)
def r; return *nil; end; *a = *r(); assert_equal(a, [nil]) def r; return *nil; end; *a = *r(); assert_equal([nil], a)
def r; return *1; end; *a = *r(); assert_equal(a, [1]) def r; return *1; end; *a = *r(); assert_equal([1], a)
def r; return *[]; end; *a = *r(); assert_equal(a, [nil]) def r; return *[]; end; *a = *r(); assert_equal([nil], a)
def r; return *[1]; end; *a = *r(); assert_equal(a, [1]) def r; return *[1]; end; *a = *r(); assert_equal([1], a)
def r; return *[nil]; end; *a = *r(); assert_equal(a, [nil]) 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,2]; end; *a = *r(); assert_equal(a, [1,2]) def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a)
def r; return *[*[]]; end; *a = *r(); assert_equal(a, [nil]) def r; return *[*[]]; end; *a = *r(); assert_equal([nil], a)
def r; return *[*[1]]; end; *a = *r(); assert_equal(a, [1]) def r; return *[*[1]]; end; *a = *r(); assert_equal([1], a)
def r; return *[*[1,2]]; end; *a = *r(); assert_equal(a, [1,2]) def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a)
def r; return; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [[],nil,[]]) 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([a,b,c], [1,2,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) 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([a,b,c], [1,2,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,2,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) 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([a,b,c], [1,2,[]]) def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
end end
def test_lambda def test_lambda
@ -247,32 +247,32 @@ class TestAssignment < Test::Unit::TestCase
f.call([], *[1]) f.call([], *[1])
f = lambda{|x| x} f = lambda{|x| x}
assert_equal(f.call(42), 42) assert_equal(42, f.call(42))
assert_equal(f.call([42]), [42]) assert_equal([42], f.call([42]))
assert_equal(f.call([[42]]), [[42]]) assert_equal([[42]], f.call([[42]]))
assert_equal(f.call([42,55]), [42,55]) assert_equal([42,55], f.call([42,55]))
f = lambda{|x,| x} f = lambda{|x,| x}
assert_equal(f.call(42), 42) assert_equal(42, f.call(42))
assert_equal(f.call([42]), [42]) assert_equal([42], f.call([42]))
assert_equal(f.call([[42]]), [[42]]) assert_equal([[42]], f.call([[42]]))
assert_equal(f.call([42,55]), [42,55]) assert_equal([42,55], f.call([42,55]))
f = lambda{|*x| x} f = lambda{|*x| x}
assert_equal(f.call(42), [42]) assert_equal([42], f.call(42))
assert_equal(f.call([42]), [[42]]) assert_equal([[42]], f.call([42]))
assert_equal(f.call([[42]]), [[[42]]]) assert_equal([[[42]]], f.call([[42]]))
assert_equal(f.call([42,55]), [[42,55]]) assert_equal([[42,55]], f.call([42,55]))
assert_equal(f.call(42,55), [42,55]) assert_equal([42,55], f.call(42,55))
end end
def test_multi def test_multi
a,=*[1] a,=*[1]
assert_equal(a, 1) assert_equal(1, a)
a,=*[[1]] a,=*[[1]]
assert_equal(a, [1]) assert_equal([1], a)
a,=*[[[1]]] a,=*[[[1]]]
assert_equal(a, [[1]]) assert_equal([[1]], a)
x, (y, z) = 1, 2, 3 x, (y, z) = 1, 2, 3
assert_equal([1,2,nil], [x,y,z]) assert_equal([1,2,nil], [x,y,z])
@ -283,87 +283,87 @@ class TestAssignment < Test::Unit::TestCase
end end
def test_break def test_break
a = loop do break; end; assert_equal(a, nil) a = loop do break; end; assert_nil(a)
a = loop do break nil; end; assert_equal(a, nil) a = loop do break nil; end; assert_nil(a)
a = loop do break 1; end; assert_equal(a, 1) a = loop do break 1; end; assert_equal(1, 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(a, [1]) a = loop do break [1]; end; assert_equal([1], a)
a = loop do break [nil]; end; assert_equal(a, [nil]) 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 [*[]]; 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]]; end; assert_equal([1], a)
a = loop do break [*[1,2]]; end; assert_equal(a, [1,2]) a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
a = loop do break *nil; end; assert_equal(a, nil) a = loop do break *nil; end; assert_nil(a)
a = loop do break *1; end; assert_equal(a, 1) a = loop do break *1; end; assert_equal(1, a)
a = loop do break *[]; end; assert_equal(a, nil) a = loop do break *[]; end; assert_nil(a)
a = loop do break *[1]; end; assert_equal(a, 1) a = loop do break *[1]; end; assert_equal(1, a)
a = loop do break *[nil]; end; assert_equal(a, nil) a = loop do break *[nil]; end; assert_nil(a)
a = loop do break *[[]]; end; assert_equal(a, []) a = loop do break *[[]]; end; assert_equal([], a)
a = loop do break *[*[]]; end; assert_equal(a, nil) a = loop do break *[*[]]; end; assert_nil(a)
a = loop do break *[*[1]]; end; assert_equal(a, 1) a = loop do break *[*[1]]; end; assert_equal(1, a)
a = loop do break *[*[1,2]]; end; assert_equal(a, [1,2]) a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
*a = loop do break; end; assert_equal(a, [nil]) *a = loop do break; end; assert_equal([nil], a)
*a = loop do break nil; end; assert_equal(a, [nil]) *a = loop do break nil; end; assert_equal([nil], a)
*a = loop do break 1; end; assert_equal(a, [1]) *a = loop do break 1; end; assert_equal([1], 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(a, [[1]]) *a = loop do break [1]; end; assert_equal([[1]], a)
*a = loop do break [nil]; end; assert_equal(a, [[nil]]) *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,2]; end; assert_equal(a, [[1,2]]) *a = loop do break [1,2]; end; assert_equal([[1,2]], 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(a, [[1]]) *a = loop do break [*[1]]; end; assert_equal([[1]], a)
*a = loop do break [*[1,2]]; end; assert_equal(a, [[1,2]]) *a = loop do break [*[1,2]]; end; assert_equal([[1,2]], a)
*a = loop do break *nil; end; assert_equal(a, [nil]) *a = loop do break *nil; end; assert_equal([nil], a)
*a = loop do break *1; end; assert_equal(a, [1]) *a = loop do break *1; end; assert_equal([1], a)
*a = loop do break *[]; end; assert_equal(a, [nil]) *a = loop do break *[]; end; assert_equal([nil], a)
*a = loop do break *[1]; end; assert_equal(a, [1]) *a = loop do break *[1]; end; assert_equal([1], a)
*a = loop do break *[nil]; end; assert_equal(a, [nil]) *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,2]; end; assert_equal(a, [[1,2]]) *a = loop do break *[1,2]; end; assert_equal([[1,2]], a)
*a = loop do break *[*[]]; end; assert_equal(a, [nil]) *a = loop do break *[*[]]; end; assert_equal([nil], a)
*a = loop do break *[*[1]]; end; assert_equal(a, [1]) *a = loop do break *[*[1]]; end; assert_equal([1], a)
*a = loop do break *[*[1,2]]; end; assert_equal(a, [[1,2]]) *a = loop do break *[*[1,2]]; end; assert_equal([[1,2]], a)
*a = *loop do break *nil; end; assert_equal(a, [nil]) *a = *loop do break *nil; end; assert_equal([nil], a)
*a = *loop do break *1; end; assert_equal(a, [1]) *a = *loop do break *1; end; assert_equal([1], a)
*a = *loop do break *[]; end; assert_equal(a, [nil]) *a = *loop do break *[]; end; assert_equal([nil], a)
*a = *loop do break *[1]; end; assert_equal(a, [1]) *a = *loop do break *[1]; end; assert_equal([1], a)
*a = *loop do break *[nil]; end; assert_equal(a, [nil]) *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,2]; end; assert_equal(a, [1,2]) *a = *loop do break *[1,2]; end; assert_equal([1,2], a)
*a = *loop do break *[*[]]; end; assert_equal(a, [nil]) *a = *loop do break *[*[]]; end; assert_equal([nil], a)
*a = *loop do break *[*[1]]; end; assert_equal(a, [1]) *a = *loop do break *[*[1]]; end; assert_equal([1], a)
*a = *loop do break *[*[1,2]]; end; assert_equal(a, [1,2]) *a = *loop do break *[*[1,2]]; end; assert_equal([1,2], a)
a,b,*c = loop do break; end; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = loop do break; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break nil; end; assert_equal([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) a,b,*c = loop do break 1; end; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = loop do break []; end; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = loop do break []; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break [1]; end; assert_equal([a,b,c], [1,nil,[]]) 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([a,b,c], [nil,nil,[]]) a,b,*c = loop do break [nil]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break [[]]; end; assert_equal([a,b,c], [[],nil,[]]) a,b,*c = loop do break [[]]; end; assert_equal([[],nil,[]], [a,b,c])
a,b,*c = loop do break [1,2]; end; assert_equal([a,b,c], [1,2,[]]) 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([a,b,c], [nil,nil,[]]) a,b,*c = loop do break [*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break [*[1]]; end; assert_equal([a,b,c], [1,nil,[]]) 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([a,b,c], [1,2,[]]) 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([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,nil,[]]) a,b,*c = loop do break *1; end; assert_equal([1,nil,[]], [a,b,c])
a,b,*c = loop do break *[]; end; assert_equal([a,b,c], [nil,nil,[]]) a,b,*c = loop do break *[]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break *[1]; end; assert_equal([a,b,c], [1,nil,[]]) 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([a,b,c], [nil,nil,[]]) a,b,*c = loop do break *[nil]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break *[[]]; end; assert_equal([a,b,c], [nil,nil,[]]) 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([a,b,c], [1,2,[]]) 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([a,b,c], [nil,nil,[]]) a,b,*c = loop do break *[*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
a,b,*c = loop do break *[*[1]]; end; assert_equal([a,b,c], [1,nil,[]]) 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([a,b,c], [1,2,[]]) a,b,*c = loop do break *[*[1,2]]; end; assert_equal([1,2,[]], [a,b,c])
end end
def test_next 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}
r(nil){next nil} r(nil){next nil}
r(1){next 1} r(1){next 1}
@ -385,7 +385,7 @@ class TestAssignment < Test::Unit::TestCase
r(1){next *[*[1]]} r(1){next *[*[1]]}
r([1,2]){next *[*[1,2]]} 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}
r([nil]){next nil} r([nil]){next nil}
r([1]){next 1} r([1]){next 1}
@ -398,7 +398,7 @@ class TestAssignment < Test::Unit::TestCase
r([[1]]){next [*[1]]} r([[1]]){next [*[1]]}
r([[1,2]]){next [*[1,2]]} 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([nil]){next *nil}
r([1]){next *1} r([1]){next *1}
r([nil]){next *[]} r([nil]){next *[]}
@ -410,7 +410,7 @@ class TestAssignment < Test::Unit::TestCase
r([1]){next *[*[1]]} r([1]){next *[*[1]]}
r([1,2]){next *[*[1,2]]} 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}
r([nil,nil,[]]){next nil} r([nil,nil,[]]){next nil}
r([1,nil,[]]){next 1} r([1,nil,[]]){next 1}
@ -423,7 +423,7 @@ class TestAssignment < Test::Unit::TestCase
r([1,nil,[]]){next [*[1]]} r([1,nil,[]]){next [*[1]]}
r([1,2,[]]){next [*[1,2]]} 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([nil,nil,[]]){next *nil}
r([1,nil,[]]){next *1} r([1,nil,[]]){next *1}
r([nil,nil,[]]){next *[]} r([nil,nil,[]]){next *[]}
@ -439,7 +439,7 @@ class TestAssignment < Test::Unit::TestCase
def test_assign2 def test_assign2
a = nil a = nil
assert(defined?(a)) assert(defined?(a))
assert_equal(a, nil) assert_nil(a)
# multiple asignment # multiple asignment
a, b = 1, 2 a, b = 1, 2
@ -449,7 +449,7 @@ class TestAssignment < Test::Unit::TestCase
assert(a == 2 && b == 1) assert(a == 2 && b == 1)
a, = 1,2 a, = 1,2
assert_equal(a, 1) assert_equal(1, a)
a, *b = 1, 2, 3 a, *b = 1, 2, 3
assert(a == 1 && b == [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) assert(a == 1 && b == 2 && c == 3 && d == 4)
*a = 1, 2, 3 *a = 1, 2, 3
assert_equal(a, [1, 2, 3]) assert_equal([1, 2, 3], a)
*a = 4 *a = 4
assert_equal(a, [4]) assert_equal([4], a)
*a = nil *a = nil
assert_equal(a, [nil]) assert_equal([nil], a)
end end
end end

37
test/ruby/test_bignum.rb
View file

@ -19,48 +19,37 @@ class TestBignum < Test::Unit::TestCase
assert_equal($x, fact(40)) assert_equal($x, fact(40))
assert($x < $x+2) assert($x < $x+2)
assert($x > $x-2) assert($x > $x-2)
assert_equal($x, 815915283247897734345611269596115894272000000000) assert_equal(815915283247897734345611269596115894272000000000, $x)
assert_not_equal($x, 815915283247897734345611269596115894272000000001) assert_not_equal(815915283247897734345611269596115894272000000001, $x)
assert_equal($x+1, 815915283247897734345611269596115894272000000001) assert_equal(815915283247897734345611269596115894272000000001, $x+1)
assert_equal($x/fact(20), 335367096786357081410764800000) assert_equal(335367096786357081410764800000, $x/fact(20))
$x = -$x $x = -$x
assert_equal($x, -815915283247897734345611269596115894272000000000) assert_equal(-815915283247897734345611269596115894272000000000, $x)
assert_equal(2-(2**32), -(2**32-2)) assert_equal(2-(2**32), -(2**32-2))
assert_equal(2**32 - 5, (2**32-3)-2) assert_equal(2**32 - 5, (2**32-3)-2)
$good = true;
for i in 1000..1014 for i in 1000..1014
$good = false if ((1<<i) != (2**i)) assert_equal(2 ** i, 1 << i)
end end
assert($good)
$good = true;
n1 = 1 << 1000 n1 = 1 << 1000
for i in 1000..1014 for i in 1000..1014
$good = false if ((1<<i) != n1) assert_equal(n1, 1 << i)
n1 *= 2 n1 *= 2
end end
assert($good)
$good = true;
n2=n1 n2=n1
for i in 1..10 for i in 1..10
n1 = n1 / 2 n1 = n1 / 2
n2 = n2 >> 1 n2 = n2 >> 1
$good = false if (n1 != n2) assert_equal(n1, n2)
end end
assert($good)
$good = true;
for i in 4000..4096 for i in 4000..4096
n1 = 1 << i; n1 = 1 << i;
if (n1**2-1) / (n1+1) != (n1-1) assert_equal(n1-1, (n1**2-1) / (n1+1))
p i
$good = false
end end
end end
assert($good)
end
def test_calc def test_calc
b = 10**80 b = 10**80
@ -74,13 +63,13 @@ 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(-7, (-a).remainder(-b))
assert_equal(10**40+10**20, 10000000000000000000100000000000000000000) assert_equal(10000000000000000000100000000000000000000, 10**40+10**20)
assert_equal(10**40/10**20, 100000000000000000000) assert_equal(100000000000000000000, 10**40/10**20)
a = 677330545177305025495135714080 a = 677330545177305025495135714080
b = 14269972710765292560 b = 14269972710765292560
assert_equal(a % b, 0) assert_equal(0, a % b)
assert_equal(-a % b, 0) assert_equal(0, -a % b)
end end
def test_shift def test_shift

23
test/ruby/test_call.rb
View file

@ -10,23 +10,12 @@ class TestCall < Test::Unit::TestCase
end end
def test_call def test_call
begin assert_raises(ArgumentError) {aaa()}
aaa() # need at least 1 arg assert_raises(ArgumentError) {aaa}
assert(false)
rescue
assert(true)
end
begin assert_equal([1, 100], aaa(1))
aaa # no arg given (exception raised) assert_equal([1, 2], aaa(1, 2))
assert(false) assert_equal([1, 2, 3, 4], aaa(1, 2, 3, 4))
rescue assert_equal([1, 2, 3, 4], aaa(1, *[2, 3, 4]))
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])
end end
end end

15
test/ruby/test_clone.rb
View file

@ -19,17 +19,12 @@ class TestClone < Test::Unit::TestCase
"test2" "test2"
end end
assert_equal(bar.test2, "test2") assert_equal("test2", bar.test2)
assert_equal(bar.test, "test") assert_equal("test", bar.test)
assert_equal(foo.test, "test") assert_equal("test", foo.test)
begin assert_raises(NoMethodError) {foo.test2}
foo.test2
assert false
rescue NoMethodError
assert true
end
assert_equal(M003.ancestors, [M003, M002, M001]) assert_equal([M003, M002, M001], M003.ancestors)
end end
end end

10
test/ruby/test_const.rb
View file

@ -20,16 +20,16 @@ class TestConst < Test::Unit::TestCase
self.class.class_eval { self.class.class_eval {
include Const 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 { self.class.class_eval {
include Const2 include Const2
} }
STDERR.print "intentionally redefines TEST3, TEST4\n" if $VERBOSE STDERR.print "intentionally redefines TEST3, TEST4\n" if $VERBOSE
assert_equal([TEST1,TEST2,TEST3,TEST4], [1,2,6,8]) assert_equal([1,2,6,8], [TEST1,TEST2,TEST3,TEST4])
assert_equal((String <=> Object), -1) assert_equal(-1, (String <=> Object))
assert_equal((Object <=> String), 1) assert_equal(1, (Object <=> String))
assert_equal((Array <=> String), nil) assert_equal(nil, (Array <=> String))
end end
end end

4
test/ruby/test_defined.rb
View file

@ -22,7 +22,7 @@ class TestDefined < Test::Unit::TestCase
$x = nil $x = nil
assert(defined?($x)) # global variable assert(defined?($x)) # global variable
assert_equal(defined?($x), 'global-variable')# returns description assert_equal('global-variable', defined?($x))# returns description
foo=5 foo=5
assert(defined?(foo)) # local variable assert(defined?(foo)) # local variable
@ -33,7 +33,7 @@ class TestDefined < Test::Unit::TestCase
assert(defined?(1 == 2)) # operator expression assert(defined?(1 == 2)) # operator expression
f = Foo.new f = Foo.new
assert_equal(defined?(f.foo), nil) assert_nil(defined?(f.foo))
f.bar(f) { |v| assert(v) } f.bar(f) { |v| assert(v) }
assert(defined_test) # not iterator assert(defined_test) # not iterator

48
test/ruby/test_eval.rb
View file

@ -13,7 +13,7 @@ class TestEval < Test::Unit::TestCase
end end
def test_eval def test_eval
assert_equal(eval(""), nil) assert_nil(eval(""))
$bad=false $bad=false
eval 'while false; $bad = true; print "foo\n" end' eval 'while false; $bad = true; print "foo\n" end'
assert(!$bad) assert(!$bad)
@ -32,16 +32,16 @@ class TestEval < Test::Unit::TestCase
assert(false) assert(false)
end end
assert_equal(eval("$foo"), 'assert(true)') assert_equal('assert(true)', eval("$foo"))
assert_equal(eval("true"), true) assert_equal(true, eval("true"))
i = 5 i = 5
assert(eval("i == 5")) assert(eval("i == 5"))
assert_equal(eval("i"), 5) assert_equal(5, eval("i"))
assert(eval("defined? i")) assert(eval("defined? i"))
$x = test_ev $x = test_ev
assert_equal(eval("local1", $x), "local1") # normal local var assert_equal("local1", eval("local1", $x)) # normal local var
assert_equal(eval("local2", $x), "local2") # nested local var assert_equal("local2", eval("local2", $x)) # nested local var
$bad = true $bad = true
begin begin
p eval("local1") p eval("local1")
@ -58,8 +58,8 @@ class TestEval < Test::Unit::TestCase
$x = binding $x = binding
end end
) )
assert_equal(eval("EVTEST1", $x), 25) # constant in module assert_equal(25, eval("EVTEST1", $x)) # constant in module
assert_equal(eval("evtest2", $x), 125) # local var in module assert_equal(125, eval("evtest2", $x)) # local var in module
$bad = true $bad = true
begin begin
eval("EVTEST1") eval("EVTEST1")
@ -70,25 +70,25 @@ class TestEval < Test::Unit::TestCase
x = proc{} x = proc{}
eval "i4 = 1", x eval "i4 = 1", x
assert_equal(eval("i4", x), 1) assert_equal(1, eval("i4", x))
x = proc{proc{}}.call x = proc{proc{}}.call
eval "i4 = 22", x eval "i4 = 22", x
assert_equal(eval("i4", x), 22) assert_equal(22, eval("i4", x))
$x = [] $x = []
x = proc{proc{}}.call x = proc{proc{}}.call
eval "(0..9).each{|i5| $x[i5] = proc{i5*2}}", x 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 x = binding
eval "i = 1", x eval "i = 1", x
assert_equal(eval("i", x), 1) assert_equal(1, eval("i", x))
x = proc{binding}.call x = proc{binding}.call
eval "i = 22", x eval "i = 22", x
assert_equal(eval("i", x), 22) assert_equal(22, eval("i", x))
$x = [] $x = []
x = proc{binding}.call x = proc{binding}.call
eval "(0..9).each{|i5| $x[i5] = proc{i5*2}}", x 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 x = proc{binding}.call
eval "for i6 in 1..1; j6=i6; end", x eval "for i6 in 1..1; j6=i6; end", x
assert(eval("defined? i6", x)) assert(eval("defined? i6", x))
@ -100,25 +100,25 @@ class TestEval < Test::Unit::TestCase
foo22 = 5 foo22 = 5
proc{foo11=22}.call proc{foo11=22}.call
proc{foo22=55}.call proc{foo22=55}.call
assert_equal(eval("foo11", p), eval("foo11")) assert_equal(eval("foo11"), eval("foo11", p))
assert_equal(eval("foo11"), 1) assert_equal(1, eval("foo11"))
assert_equal(eval("foo22", p), eval("foo22")) assert_equal(eval("foo22"), eval("foo22", p))
assert_equal(eval("foo22"), 55) assert_equal(55, eval("foo22"))
}.call }.call
p1 = proc{i7 = 0; proc{i7}}.call p1 = proc{i7 = 0; proc{i7}}.call
assert_equal(p1.call, 0) assert_equal(0, p1.call)
eval "i7=5", p1 eval "i7=5", p1
assert_equal(p1.call, 5) assert_equal(5, p1.call)
assert(!defined?(i7)) assert(!defined?(i7))
p1 = proc{i7 = 0; proc{i7}}.call p1 = proc{i7 = 0; proc{i7}}.call
i7 = nil i7 = nil
assert_equal(p1.call, 0) assert_equal(0, p1.call)
eval "i7=1", p1 eval "i7=1", p1
assert_equal(p1.call, 1) assert_equal(1, p1.call)
eval "i7=5", p1 eval "i7=5", p1
assert_equal(p1.call, 5) assert_equal(5, p1.call)
assert_equal(i7, nil) assert_nil(i7)
end end
end end

13
test/ruby/test_exception.rb
View file

@ -25,28 +25,29 @@ class TestException < Test::Unit::TestCase
# exception in rescue clause # exception in rescue clause
$string = "this must be handled no.3" $string = "this must be handled no.3"
begin e = assert_raises(RuntimeError) do
begin begin
raise "exception in rescue clause" raise "exception in rescue clause"
rescue rescue
raise $string raise $string
end end
assert(false) assert(false)
rescue
assert(true) if $! == $string
end end
assert_equal($string, e.message)
# exception in ensure clause # exception in ensure clause
begin $string = "exception in ensure clause"
e = assert_raises(RuntimeError) do
begin begin
raise "this must be handled no.4" 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" raise "exception in ensure clause"
end end
assert(false) assert(false)
rescue
assert(true)
end end
assert_equal($string, e.message)
$bad = true $bad = true
begin begin

24
test/ruby/test_float.rb
View file

@ -4,23 +4,23 @@ $KCODE = 'none'
class TestFloat < Test::Unit::TestCase class TestFloat < Test::Unit::TestCase
def test_float def test_float
assert_equal(2.6.floor, 2) assert_equal(2, 2.6.floor)
assert_equal((-2.6).floor, -3) assert_equal(-3, (-2.6).floor)
assert_equal(2.6.ceil, 3) assert_equal(3, 2.6.ceil)
assert_equal((-2.6).ceil, -2) assert_equal(-2, (-2.6).ceil)
assert_equal(2.6.truncate, 2) assert_equal(2, 2.6.truncate)
assert_equal((-2.6).truncate, -2) assert_equal(-2, (-2.6).truncate)
assert_equal(2.6.round, 3) assert_equal(3, 2.6.round)
assert_equal((-2.4).truncate, -2) assert_equal(-2, (-2.4).truncate)
assert((13.4 % 1 - 0.4).abs < 0.0001) assert((13.4 % 1 - 0.4).abs < 0.0001)
nan = 0.0/0 nan = 0.0/0
def nan.test(v) def nan.test(v)
extend Test::Unit::Assertions extend Test::Unit::Assertions
assert(self != v) assert(self != v)
assert_equal((self < v), false) assert_equal(false, (self < v))
assert_equal((self > v), false) assert_equal(false, (self > v))
assert_equal((self <= v), false) assert_equal(false, (self <= v))
assert_equal((self >= v), false) assert_equal(false, (self >= v))
end end
nan.test(nan) nan.test(nan)
nan.test(0) nan.test(0)

5
test/ruby/test_gc.rb
View file

@ -10,14 +10,11 @@ class TestGc < Test::Unit::TestCase
end end
def test_gc def test_gc
begin assert_nothing_raised do
1.upto(10000) { 1.upto(10000) {
tmp = [0,1,2,3,4,5,6,7,8,9] tmp = [0,1,2,3,4,5,6,7,8,9]
} }
tmp = nil tmp = nil
assert true
rescue
assert false
end end
l=nil l=nil
100000.times { 100000.times {

42
test/ruby/test_hash.rb
View file

@ -7,7 +7,7 @@ class TestHash < Test::Unit::TestCase
$x = {1=>2, 2=>4, 3=>6} $x = {1=>2, 2=>4, 3=>6}
$y = {1, 2, 2, 4, 3, 6} $y = {1, 2, 2, 4, 3, 6}
assert_equal($x[1], 2) assert_equal(2, $x[1])
assert(begin assert(begin
for k,v in $y for k,v in $y
@ -18,48 +18,48 @@ class TestHash < Test::Unit::TestCase
false false
end) end)
assert_equal($x.length, 3) assert_equal(3, $x.length)
assert($x.has_key?(1)) assert($x.has_key?(1))
assert($x.has_value?(4)) assert($x.has_value?(4))
assert_equal($x.values_at(2,3), [4,6]) assert_equal([4,6], $x.values_at(2,3))
assert_equal($x, {1=>2, 2=>4, 3=>6}) assert_equal({1=>2, 2=>4, 3=>6}, $x)
$z = $y.keys.join(":") $z = $y.keys.join(":")
assert_equal($z, "1:2:3") assert_equal("1:2:3", $z)
$z = $y.values.join(":") $z = $y.values.join(":")
assert_equal($z, "2:4:6") assert_equal("2:4:6", $z)
assert_equal($x, $y) assert_equal($x, $y)
$y.shift $y.shift
assert_equal($y.length, 2) assert_equal(2, $y.length)
$z = [1,2] $z = [1,2]
$y[$z] = 256 $y[$z] = 256
assert_equal($y[$z], 256) assert_equal(256, $y[$z])
$x = Hash.new(0) $x = Hash.new(0)
$x[1] = 1 $x[1] = 1
assert_equal($x[1], 1) assert_equal(1, $x[1])
assert_equal($x[2], 0) assert_equal(0, $x[2])
$x = Hash.new([]) $x = Hash.new([])
assert_equal($x[22], []) assert_equal([], $x[22])
assert($x[22].equal?($x[22])) assert($x[22].equal?($x[22]))
$x = Hash.new{[]} $x = Hash.new{[]}
assert_equal($x[22], []) assert_equal([], $x[22])
assert(!$x[22].equal?($x[22])) assert(!$x[22].equal?($x[22]))
$x = Hash.new{|h,k| $z = k; h[k] = k*2} $x = Hash.new{|h,k| $z = k; h[k] = k*2}
$z = 0 $z = 0
assert_equal($x[22], 44) assert_equal(44, $x[22])
assert_equal($z, 22) assert_equal(22, $z)
$z = 0 $z = 0
assert_equal($x[22], 44) assert_equal(44, $x[22])
assert_equal($z, 0) assert_equal(0, $z)
$x.default = 5 $x.default = 5
assert_equal($x[23], 5) assert_equal(5, $x[23])
$x = Hash.new $x = Hash.new
def $x.default(k) def $x.default(k)
@ -67,10 +67,10 @@ class TestHash < Test::Unit::TestCase
self[k] = k*2 self[k] = k*2
end end
$z = 0 $z = 0
assert_equal($x[22], 44) assert_equal(44, $x[22])
assert_equal($z, 22) assert_equal(22, $z)
$z = 0 $z = 0
assert_equal($x[22], 44) assert_equal(44, $x[22])
assert_equal($z, 0) assert_equal(0, $z)
end end
end end

4
test/ruby/test_iterator.rb
View file

@ -182,8 +182,8 @@ class TestIterator < Test::Unit::TestCase
def test_block_in_arg def test_block_in_arg
assert(m1{p 'test'}) assert(m1{p 'test'})
assert(m2{p 'test'}) assert(m2{p 'test'})
assert(!m1) assert(!m1())
assert(!m2) assert(!m2())
end end
class C class C

2
test/ruby/test_marshal.rb
View file

@ -20,7 +20,7 @@ class TestMarshal < Test::Unit::TestCase
$y = Marshal.dump($x) $y = Marshal.dump($x)
assert_equal($x, Marshal.load($y)) 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| [[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)) a = (x.to_f + y.to_f / z.to_f) * Math.exp(w.to_f / (x.to_f + y.to_f / z.to_f))

4
test/ruby/test_math.rb
View file

@ -4,11 +4,11 @@ $KCODE = 'none'
class TestMath < Test::Unit::TestCase class TestMath < Test::Unit::TestCase
def test_math def test_math
assert_equal(Math.sqrt(4), 2) assert_equal(2, Math.sqrt(4))
self.class.class_eval { self.class.class_eval {
include Math include Math
} }
assert_equal(sqrt(4), 2) assert_equal(2, sqrt(4))
end end
end end

2
test/ruby/test_pack.rb
View file

@ -16,6 +16,6 @@ class TestPack < Test::Unit::TestCase
assert($x =~ /def/) assert($x =~ /def/)
$x = [-1073741825] $x = [-1073741825]
assert_equal($x.pack("q").unpack("q"), $x) assert_equal($x, $x.pack("q").unpack("q"))
end end
end end

62
test/ruby/test_path.rb
View file

@ -4,45 +4,45 @@ $KCODE = 'none'
class TestPath < Test::Unit::TestCase class TestPath < Test::Unit::TestCase
def test_path def test_path
assert_equal(File.basename("a"), "a") assert_equal("a", File.basename("a"))
assert_equal(File.basename("a/b"), "b") assert_equal("b", File.basename("a/b"))
assert_equal(File.basename("a/b/"), "b") assert_equal("b", File.basename("a/b/"))
assert_equal(File.basename("/"), "/") assert_equal("/", File.basename("/"))
assert_equal(File.basename("//"), "/") assert_equal("/", File.basename("//"))
assert_equal(File.basename("///"), "/") assert_equal("/", File.basename("///"))
assert_equal(File.basename("a/b////"), "b") assert_equal("b", File.basename("a/b////"))
assert_equal(File.basename("a.rb", ".rb"), "a") assert_equal("a", File.basename("a.rb", ".rb"))
assert_equal(File.basename("a.rb///", ".rb"), "a") assert_equal("a", File.basename("a.rb///", ".rb"))
assert_equal(File.basename("a.rb///", ".*"), "a") assert_equal("a", File.basename("a.rb///", ".*"))
assert_equal(File.basename("a.rb///", ".c"), "a.rb") assert_equal("a.rb", File.basename("a.rb///", ".c"))
assert_equal(File.dirname("a"), ".") assert_equal(".", File.dirname("a"))
assert_equal(File.dirname("/"), "/") assert_equal("/", File.dirname("/"))
assert_equal(File.dirname("/a"), "/") assert_equal("/", File.dirname("/a"))
assert_equal(File.dirname("a/b"), "a") assert_equal("a", File.dirname("a/b"))
assert_equal(File.dirname("a/b/c"), "a/b") assert_equal("a/b", File.dirname("a/b/c"))
assert_equal(File.dirname("/a/b/c"), "/a/b") assert_equal("/a/b", File.dirname("/a/b/c"))
assert_equal(File.dirname("/a/b/"), "/a") assert_equal("/a", File.dirname("/a/b/"))
assert_equal(File.dirname("/a/b///"), "/a") assert_equal("/a", File.dirname("/a/b///"))
case Dir.pwd case Dir.pwd
when %r'\A\w:' when %r'\A\w:'
assert(/\A\w:\/\z/ =~ File.expand_path(".", "/")) assert_match(/\A\w:\/\z/, File.expand_path(".", "/"))
assert(/\A\w:\/a\z/ =~ File.expand_path("a", "/")) assert_match(/\A\w:\/a\z/, File.expand_path("a", "/"))
dosish = true dosish = true
when %r'\A//' when %r'\A//'
assert(%r'\A//[^/]+/[^/]+\z' =~ File.expand_path(".", "/")) assert_match(%r'\A//[^/]+/[^/]+\z', File.expand_path(".", "/"))
assert(%r'\A//[^/]+/[^/]+/a\z' =~ File.expand_path(".", "/")) assert_match(%r'\A//[^/]+/[^/]+/a\z', File.expand_path(".", "/"))
dosish = true dosish = true
else else
assert_equal(File.expand_path(".", "/"), "/") assert_equal("/", File.expand_path(".", "/"))
assert_equal(File.expand_path("sub", "/"), "/sub") assert_equal("/sub", File.expand_path("sub", "/"))
end end
if dosish if dosish
assert_equal(File.expand_path("/", "//machine/share/sub"), "//machine/share") assert_equal("//machine/share", File.expand_path("/", "//machine/share/sub"))
assert_equal(File.expand_path("/dir", "//machine/share/sub"), "//machine/share/dir") assert_equal("//machine/share/dir", File.expand_path("/dir", "//machine/share/sub"))
assert_equal(File.expand_path("/", "z:/sub"), "z:/") assert_equal("z:/", File.expand_path("/", "z:/sub"))
assert_equal(File.expand_path("/dir", "z:/sub"), "z:/dir") assert_equal("z:/dir", File.expand_path("/dir", "z:/sub"))
end end
assert_equal(File.expand_path(".", "//"), "//") assert_equal("//", File.expand_path(".", "//"))
assert_equal(File.expand_path("sub", "//"), "//sub") assert_equal("//sub", File.expand_path("sub", "//"))
end end
end end

12
test/ruby/test_proc.rb
View file

@ -5,12 +5,12 @@ $KCODE = 'none'
class TestProc < Test::Unit::TestCase class TestProc < Test::Unit::TestCase
def test_proc def test_proc
$proc = proc{|i| i} $proc = proc{|i| i}
assert_equal($proc.call(2), 2) assert_equal(2, $proc.call(2))
assert_equal($proc.call(3), 3) assert_equal(3, $proc.call(3))
$proc = proc{|i| i*2} $proc = proc{|i| i*2}
assert_equal($proc.call(2), 4) assert_equal(4, $proc.call(2))
assert_equal($proc.call(3), 6) assert_equal(6, $proc.call(3))
proc{ proc{
iii=5 # nested local variable iii=5 # nested local variable
@ -28,7 +28,7 @@ class TestProc < Test::Unit::TestCase
loop{iii=5; assert(eval("defined? iii")); break} loop{iii=5; assert(eval("defined? iii")); break}
loop { loop {
iii = 10 iii = 10
def dyna_var_check def self.dyna_var_check
loop { loop {
assert(!defined?(iii)) assert(!defined?(iii))
break break
@ -40,6 +40,6 @@ class TestProc < Test::Unit::TestCase
$x=0 $x=0
$proc.call(5) $proc.call(5)
$proc2.call $proc2.call
assert_equal($x, 5) assert_equal(5, $x)
end end
end end

10
test/ruby/test_signal.rb
View file

@ -9,18 +9,16 @@ class TestSignal < Test::Unit::TestCase
trap "SIGINT", proc{|sig| $x = 2} trap "SIGINT", proc{|sig| $x = 2}
Process.kill "SIGINT", $$ Process.kill "SIGINT", $$
sleep 0.1 sleep 0.1
assert_equal($x, 2) assert_equal(2, $x)
trap "SIGINT", proc{raise "Interrupt"} trap "SIGINT", proc{raise "Interrupt"}
x = false x = assert_raises(RuntimeError) do
begin
Process.kill "SIGINT", $$ Process.kill "SIGINT", $$
sleep 0.1 sleep 0.1
rescue
x = $!
end end
assert(x && /Interrupt/ =~ x.message) assert(x)
assert_match(/Interrupt/, x.message)
end end
end end
end end

98
test/ruby/test_stringchar.rb
View file

@ -8,77 +8,77 @@ class TestStringchar < Test::Unit::TestCase
assert("abcd" =~ /abcd/) assert("abcd" =~ /abcd/)
assert("abcd" === "abcd") assert("abcd" === "abcd")
# compile time string concatenation # compile time string concatenation
assert_equal("ab" "cd", "abcd") assert_equal("abcd", "ab" "cd")
assert_equal("#{22}aa" "cd#{44}", "22aacd44") assert_equal("22aacd44", "#{22}aa" "cd#{44}")
assert_equal("#{22}aa" "cd#{44}" "55" "#{66}", "22aacd445566") assert_equal("22aacd445566", "#{22}aa" "cd#{44}" "55" "#{66}")
assert("abc" !~ /^$/) assert("abc" !~ /^$/)
assert("abc\n" !~ /^$/) assert("abc\n" !~ /^$/)
assert("abc" !~ /^d*$/) assert("abc" !~ /^d*$/)
assert_equal(("abc" =~ /d*$/), 3) assert_equal(3, ("abc" =~ /d*$/))
assert("" =~ /^$/) assert("" =~ /^$/)
assert("\n" =~ /^$/) assert("\n" =~ /^$/)
assert("a\n\n" =~ /^$/) assert("a\n\n" =~ /^$/)
assert("abcabc" =~ /.*a/ && $& == "abca") assert("abcabc" =~ /.*a/); assert_equal("abca", $&)
assert("abcabc" =~ /.*c/ && $& == "abcabc") assert("abcabc" =~ /.*c/); assert_equal("abcabc", $&)
assert("abcabc" =~ /.*?a/ && $& == "a") assert("abcabc" =~ /.*?a/); assert_equal("a", $&)
assert("abcabc" =~ /.*?c/ && $& == "abc") assert("abcabc" =~ /.*?c/); assert_equal("abc", $&)
assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n" && $& == "a\nb") assert(/(.|\n)*?\n(b|\n)/ =~ "a\nb\n\n"); assert_equal("a\nb", $&)
assert(/^(ab+)+b/ =~ "ababb" && $& == "ababb") assert(/^(ab+)+b/ =~ "ababb"); assert_equal("ababb", $&)
assert(/^(?:ab+)+b/ =~ "ababb" && $& == "ababb") assert(/^(?:ab+)+b/ =~ "ababb"); assert_equal("ababb", $&)
assert(/^(ab+)+/ =~ "ababb" && $& == "ababb") assert(/^(ab+)+/ =~ "ababb"); assert_equal("ababb", $&)
assert(/^(?:ab+)+/ =~ "ababb" && $& == "ababb") assert(/^(?:ab+)+/ =~ "ababb"); assert_equal("ababb", $&)
assert(/(\s+\d+){2}/ =~ " 1 2" && $& == " 1 2") assert(/(\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&)
assert(/(?:\s+\d+){2}/ =~ " 1 2" && $& == " 1 2") assert(/(?:\s+\d+){2}/ =~ " 1 2"); assert_equal(" 1 2", $&)
$x = <<END; $x = <<END;
ABCD ABCD
ABCD ABCD
END END
$x.gsub!(/((.|\n)*?)B((.|\n)*?)D/){$1+$3} $x.gsub!(/((.|\n)*?)B((.|\n)*?)D/){$1+$3}
assert_equal($x, "AC\nAC\n") assert_equal("AC\nAC\n", $x)
assert("foobar" =~ /foo(?=(bar)|(baz))/) assert("foobar" =~ /foo(?=(bar)|(baz))/)
assert("foobaz" =~ /foo(?=(bar)|(baz))/) assert("foobaz" =~ /foo(?=(bar)|(baz))/)
$foo = "abc" $foo = "abc"
assert_equal("#$foo = abc", "abc = abc") assert_equal("abc = abc", "#$foo = abc")
assert_equal("#{$foo} = abc", "abc = abc") assert_equal("abc = abc", "#{$foo} = abc")
foo = "abc" foo = "abc"
assert_equal("#{foo} = abc", "abc = abc") assert_equal("abc = abc", "#{foo} = abc")
assert_equal('-' * 5, '-----') assert_equal('-----', '-' * 5)
assert_equal('-' * 1, '-') assert_equal('-', '-' * 1)
assert_equal('-' * 0, '') assert_equal('', '-' * 0)
foo = '-' foo = '-'
assert_equal(foo * 5, '-----') assert_equal('-----', foo * 5)
assert_equal(foo * 1, '-') assert_equal('-', foo * 1)
assert_equal(foo * 0, '') assert_equal('', foo * 0)
$x = "a.gif" $x = "a.gif"
assert_equal($x.sub(/.*\.([^\.]+)$/, '\1'), "gif") assert_equal("gif", $x.sub(/.*\.([^\.]+)$/, '\1'))
assert_equal($x.sub(/.*\.([^\.]+)$/, 'b.\1'), "b.gif") assert_equal("b.gif", $x.sub(/.*\.([^\.]+)$/, 'b.\1'))
assert_equal($x.sub(/.*\.([^\.]+)$/, '\2'), "") assert_equal("", $x.sub(/.*\.([^\.]+)$/, '\2'))
assert_equal($x.sub(/.*\.([^\.]+)$/, 'a\2b'), "ab") assert_equal("ab", $x.sub(/.*\.([^\.]+)$/, 'a\2b'))
assert_equal($x.sub(/.*\.([^\.]+)$/, '<\&>'), "<a.gif>") assert_equal("<a.gif>", $x.sub(/.*\.([^\.]+)$/, '<\&>'))
end end
def test_char def test_char
# character constants(assumes ASCII) # character constants(assumes ASCII)
assert_equal("a"[0], ?a) assert_equal(?a, "a"[0])
assert_equal(?a, ?a) assert_equal(?a, ?a)
assert_equal(?\C-a, 1) assert_equal(1, ?\C-a)
assert_equal(?\M-a, 225) assert_equal(225, ?\M-a)
assert_equal(?\M-\C-a, 129) assert_equal(129, ?\M-\C-a)
assert_equal("a".upcase![0], ?A) assert_equal(?A, "a".upcase![0])
assert_equal("A".downcase![0], ?a) assert_equal(?a, "A".downcase![0])
assert_equal("abc".tr!("a-z", "A-Z"), "ABC") assert_equal("ABC", "abc".tr!("a-z", "A-Z"))
assert_equal("aabbcccc".tr_s!("a-z", "A-Z"), "ABC") assert_equal("ABC", "aabbcccc".tr_s!("a-z", "A-Z"))
assert_equal("abcc".squeeze!("a-z"), "abc") assert_equal("abc", "abcc".squeeze!("a-z"))
assert_equal("abcd".delete!("bc"), "ad") assert_equal("ad", "abcd".delete!("bc"))
$x = "abcdef" $x = "abcdef"
$y = [ ?a, ?b, ?c, ?d, ?e, ?f ] $y = [ ?a, ?b, ?c, ?d, ?e, ?f ]
@ -93,26 +93,26 @@ END
s = "a string" s = "a string"
s[0..s.size]="another string" s[0..s.size]="another string"
assert_equal(s, "another string") assert_equal("another string", s)
s = <<EOS s = <<EOS
#{ #{
[1,2,3].join(",") [1,2,3].join(",")
} }
EOS EOS
assert_equal(s, "1,2,3\n") assert_equal("1,2,3\n", s)
assert_equal("Just".to_i(36), 926381) assert_equal(926381, "Just".to_i(36))
assert_equal("-another".to_i(36), -23200231779) assert_equal(-23200231779, "-another".to_i(36))
assert_equal(1299022.to_s(36), "ruby") assert_equal("ruby", 1299022.to_s(36))
assert_equal(-1045307475.to_s(36), "-hacker") assert_equal("-hacker", -1045307475.to_s(36))
assert_equal("Just_another_Ruby_hacker".to_i(36), 265419172580680477752431643787347) assert_equal(265419172580680477752431643787347, "Just_another_Ruby_hacker".to_i(36))
assert_equal(-265419172580680477752431643787347.to_s(36), "-justanotherrubyhacker") assert_equal("-justanotherrubyhacker", -265419172580680477752431643787347.to_s(36))
a = [] a = []
(0..255).each {|n| (0..255).each {|n|
ch = [n].pack("C") ch = [n].pack("C")
a.push ch if /a#{Regexp.quote ch}b/x =~ "ab" a.push ch if /a#{Regexp.quote ch}b/x =~ "ab"
} }
assert_equal(a.size, 0) assert_equal(0, a.size)
end end
end end

15
test/ruby/test_struct.rb
View file

@ -5,19 +5,22 @@ $KCODE = 'none'
class TestStruct < Test::Unit::TestCase class TestStruct < Test::Unit::TestCase
def test_struct def test_struct
struct_test = Struct.new("Test", :foo, :bar) struct_test = Struct.new("Test", :foo, :bar)
assert_equal(struct_test, Struct::Test) assert_equal(Struct::Test, struct_test)
test = struct_test.new(1, 2) test = struct_test.new(1, 2)
assert(test.foo == 1 && test.bar == 2) assert_equal(1, test.foo)
assert(test[0] == 1 && test[1] == 2) assert_equal(2, test.bar)
assert_equal(1, test[0])
assert_equal(2, test[1])
a, b = test.to_a a, b = test.to_a
assert(a == 1 && b == 2) assert_equal(1, a)
assert_equal(2, b)
test[0] = 22 test[0] = 22
assert_equal(test.foo, 22) assert_equal(22, test.foo)
test.bar = 47 test.bar = 47
assert_equal(test.bar, 47) assert_equal(47, test.bar)
end end
end end

37
test/ruby/test_system.rb
View file

@ -3,28 +3,32 @@ require 'test/unit'
$KCODE = 'none' $KCODE = 'none'
class TestSystem < Test::Unit::TestCase class TestSystem < Test::Unit::TestCase
def valid_syntax?(code, fname)
eval("BEGIN {return true}\n#{code}", nil, fname, 0)
end
def test_system def test_system
if File.exist? "miniruby" or File.exist? "miniruby.exe" if File.exist? "miniruby" or File.exist? "miniruby.exe"
ruby = "./miniruby" ruby = "./miniruby"
else else
ruby = "ruby" ruby = "ruby"
end end
assert_equal(`echo foobar`, "foobar\n") assert_equal("foobar\n", `echo foobar`)
assert_equal(`#{ruby} -e 'print "foobar"'`, 'foobar') assert_equal('foobar', `#{ruby} -e 'print "foobar"'`)
tmp = open("script_tmp", "w") tmp = open("script_tmp", "w")
tmp.print "print $zzz\n"; tmp.print "print $zzz\n";
tmp.close tmp.close
assert_equal(`#{ruby} -s script_tmp -zzz`, 'true') assert_equal('true', `#{ruby} -s script_tmp -zzz`)
assert_equal(`#{ruby} -s script_tmp -zzz=555`, '555') assert_equal('555', `#{ruby} -s script_tmp -zzz=555`)
tmp = open("script_tmp", "w") tmp = open("script_tmp", "w")
tmp.print "#! /usr/local/bin/ruby -s\n"; tmp.print "#! /usr/local/bin/ruby -s\n";
tmp.print "print $zzz\n"; tmp.print "print $zzz\n";
tmp.close tmp.close
assert_equal(`#{ruby} script_tmp -zzz=678`, '678') assert_equal('678', `#{ruby} script_tmp -zzz=678`)
tmp = open("script_tmp", "w") tmp = open("script_tmp", "w")
tmp.print "this is a leading junk\n"; tmp.print "this is a leading junk\n";
@ -34,8 +38,8 @@ class TestSystem < Test::Unit::TestCase
tmp.print "this is a trailing junk\n"; tmp.print "this is a trailing junk\n";
tmp.close tmp.close
assert_equal(`#{ruby} -x script_tmp`, 'nil') assert_equal('nil', `#{ruby} -x script_tmp`)
assert_equal(`#{ruby} -x script_tmp -zzz=555`, '555') assert_equal('555', `#{ruby} -x script_tmp -zzz=555`)
tmp = open("script_tmp", "w") tmp = open("script_tmp", "w")
for i in 1..5 for i in 1..5
@ -44,16 +48,11 @@ class TestSystem < Test::Unit::TestCase
tmp.close tmp.close
`#{ruby} -i.bak -pe 'sub(/^[0-9]+$/){$&.to_i * 5}' script_tmp` `#{ruby} -i.bak -pe 'sub(/^[0-9]+$/){$&.to_i * 5}' script_tmp`
done = true
tmp = open("script_tmp", "r") tmp = open("script_tmp", "r")
while tmp.gets while tmp.gets
if $_.to_i % 5 != 0 assert_equal(0, $_.to_i % 5)
done = false
break
end
end end
tmp.close tmp.close
assert(done)
File.unlink "script_tmp" or `/bin/rm -f "script_tmp"` File.unlink "script_tmp" or `/bin/rm -f "script_tmp"`
File.unlink "script_tmp.bak" or `/bin/rm -f "script_tmp.bak"` File.unlink "script_tmp.bak" or `/bin/rm -f "script_tmp.bak"`
@ -65,18 +64,10 @@ class TestSystem < Test::Unit::TestCase
dir << "/" dir << "/"
end end
def valid_syntax?(code, fname)
eval("BEGIN {return true}\n#{code}", nil, fname, 0)
rescue Exception
puts $!.message
false
end
for script in Dir["#{dir}{lib,sample,ext}/**/*.rb"] for script in Dir["#{dir}{lib,sample,ext}/**/*.rb"]
unless valid_syntax? IO::read(script), script assert_nothing_raised(Exception) do
$bad = true valid_syntax? IO::read(script), script
end end
end end
assert(!$bad)
end end
end end

4
test/ruby/test_trace.rb
View file

@ -8,7 +8,7 @@ class TestTrace < Test::Unit::TestCase
$y = 0 $y = 0
trace_var :$x, proc{$y = $x} trace_var :$x, proc{$y = $x}
$x = 40414 $x = 40414
assert_equal($y, $x) assert_equal($x, $y)
untrace_var :$x untrace_var :$x
$x = 19660208 $x = 19660208
@ -16,7 +16,7 @@ class TestTrace < Test::Unit::TestCase
trace_var :$x, proc{$x *= 2} trace_var :$x, proc{$x *= 2}
$x = 5 $x = 5
assert_equal($x, 10) assert_equal(10, $x)
untrace_var :$x untrace_var :$x
end end

16
test/ruby/test_variable.rb
View file

@ -44,15 +44,15 @@ class TestVariable < Test::Unit::TestCase
foobar = "foobar" foobar = "foobar"
$_ = foobar $_ = foobar
assert_equal($_, foobar) assert_equal(foobar, $_)
assert_equal(Gods.new.ruler0, "Cronus") assert_equal("Cronus", Gods.new.ruler0)
assert_equal(Gods.ruler1, "Cronus") assert_equal("Cronus", Gods.ruler1)
assert_equal(Gods.ruler2, "Cronus") assert_equal("Cronus", Gods.ruler2)
assert_equal(Titans.ruler1, "Cronus") assert_equal("Cronus", Titans.ruler1)
assert_equal(Titans.ruler2, "Cronus") assert_equal("Cronus", Titans.ruler2)
atlas = Titans.new atlas = Titans.new
assert_equal(atlas.ruler0, "Cronus") assert_equal("Cronus", atlas.ruler0)
assert_equal(atlas.ruler3, "Zeus") assert_equal("Zeus", atlas.ruler3)
end end
end end

29
test/ruby/test_whileuntil.rb
View file

@ -13,25 +13,25 @@ class TestWhileuntil < Test::Unit::TestCase
tmp.close tmp.close
tmp = open("while_tmp", "r") tmp = open("while_tmp", "r")
assert(tmp.kind_of?(File)) assert_kind_of(File, tmp)
while line = tmp.gets() while line = tmp.gets()
break if /vt100/ =~ line break if /vt100/ =~ line
end end
assert(!tmp.eof? && /vt100/ =~ line) assert(!tmp.eof?)
assert_match(/vt100/, line)
tmp.close tmp.close
$bad = false
tmp = open("while_tmp", "r") tmp = open("while_tmp", "r")
while line = tmp.gets() while line = tmp.gets()
next if /vt100/ =~ line next if /vt100/ =~ line
$bad = 1 if /vt100/ =~ line assert_no_match(/vt100/, line)
end end
assert(!(!tmp.eof? || /vt100/ =~ line || $bad)) assert(tmp.eof?)
assert_no_match(/vt100/, line)
tmp.close tmp.close
$bad = false
tmp = open("while_tmp", "r") tmp = open("while_tmp", "r")
while tmp.gets() while tmp.gets()
line = $_ line = $_
@ -40,10 +40,10 @@ class TestWhileuntil < Test::Unit::TestCase
$_.gsub!('VT100', 'Vt100') $_.gsub!('VT100', 'Vt100')
redo redo
end end
$bad = 1 if /vt100/ =~ $_ assert_no_match(/vt100/, $_)
$bad = 1 if /VT100/ =~ $_ assert_no_match(/VT100/, $_)
end end
assert(tmp.eof? && !$bad) assert(tmp.eof?)
tmp.close tmp.close
sum=0 sum=0
@ -54,18 +54,15 @@ class TestWhileuntil < Test::Unit::TestCase
redo redo
end end
end end
assert_equal(sum, 220) assert_equal(220, sum)
$bad = false
tmp = open("while_tmp", "r") tmp = open("while_tmp", "r")
while line = tmp.gets() while line = tmp.gets()
break if 3 break if 3
case line assert_no_match(/vt100/, line)
when /vt100/, /Amiga/, /paper/ assert_no_match(/Amiga/, line)
$bad = true assert_no_match(/paper/, line)
end end
end
assert(!$bad)
tmp.close tmp.close
File.unlink "while_tmp" or `/bin/rm -f "while_tmp"` File.unlink "while_tmp" or `/bin/rm -f "while_tmp"`

17
test/runner.rb
View file

@ -33,20 +33,23 @@ runners_map = {
} }
runner = 'console' runner = 'console'
ARGV.options do |opt| opt = OptionParser.new
opt.program_name = $0 opt.program_name = $0
opt.banner << " [tests...]" opt.banner << " [tests...]"
opt.on("--runner=mode", runners_map.keys, "UI mode (console, gtk,fox)") do |arg| opt.on("--runner=mode", runners_map.keys, "UI mode (console, gtk,fox)") do |arg|
runner = arg runner = arg
end end
opt.parse! begin
end or abort(ARGV.options.help) argv = opt.parse(*ARGV)
rescue OptionParser::ParseError
if ARGV.empty? opt.abort($!)
ARGV.replace(Dir.glob(File.join(File.dirname(__FILE__), "**", "test_*.rb")).sort)
end end
ARGV.each do |tc_name| if argv.empty?
argv = Dir.glob(File.join(File.dirname(__FILE__), "**", "test_*.rb")).sort
end
argv.each do |tc_name|
require tc_name require tc_name
end end