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

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

Browse source 
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4512 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nahi 2003-09-05 11:28:27 +00:00
parent d9f38cbee8
commit 65264eadbd
25 changed files with 545 additions and 539 deletions
Download patch file Download diff file Expand all files Collapse all files

4
ChangeLog
View file

@ -1,3 +1,7 @@
Fri Sep 5 20:27:08 2003 NAKAMURA, Hiroshi <nahi@ruby-lang.org>
* test/ruby/test_*.rb: replace 'assert(a == b)' with assert_equal(a, b)'
Fri Sep 5 18:00:51 2003 GOTOU Yuuzou <gotoyuzo@notwork.org>
* ext/openssl/lib/openssl/x509.rb: new method X509::Name::parse.

6
test/ruby/test_alias.rb
View file

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

66
test/ruby/test_array.rb
View file

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

604
test/ruby/test_assignment.rb
View file

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

46
test/ruby/test_bignum.rb
View file

@ -15,18 +15,18 @@ class TestBignum < Test::Unit::TestCase
def test_bignum
$x = fact(40)
assert($x == $x)
assert($x == fact(40))
assert_equal($x, $x)
assert_equal($x, fact(40))
assert($x < $x+2)
assert($x > $x-2)
assert($x == 815915283247897734345611269596115894272000000000)
assert($x != 815915283247897734345611269596115894272000000001)
assert($x+1 == 815915283247897734345611269596115894272000000001)
assert($x/fact(20) == 335367096786357081410764800000)
assert_equal($x, 815915283247897734345611269596115894272000000000)
assert_not_equal($x, 815915283247897734345611269596115894272000000001)
assert_equal($x+1, 815915283247897734345611269596115894272000000001)
assert_equal($x/fact(20), 335367096786357081410764800000)
$x = -$x
assert($x == -815915283247897734345611269596115894272000000000)
assert(2-(2**32) == -(2**32-2))
assert(2**32 - 5 == (2**32-3)-2)
assert_equal($x, -815915283247897734345611269596115894272000000000)
assert_equal(2-(2**32), -(2**32-2))
assert_equal(2**32 - 5, (2**32-3)-2)
$good = true;
for i in 1000..1014
@ -65,33 +65,33 @@ class TestBignum < Test::Unit::TestCase
def test_calc
b = 10**80
a = b * 9 + 7
assert(7 == a.modulo(b))
assert(-b + 7 == a.modulo(-b))
assert(b + -7 == (-a).modulo(b))
assert(-7 == (-a).modulo(-b))
assert(7 == a.remainder(b))
assert(7 == a.remainder(-b))
assert(-7 == (-a).remainder(b))
assert(-7 == (-a).remainder(-b))
assert_equal(7, a.modulo(b))
assert_equal(-b + 7, a.modulo(-b))
assert_equal(b + -7, (-a).modulo(b))
assert_equal(-7, (-a).modulo(-b))
assert_equal(7, a.remainder(b))
assert_equal(7, a.remainder(-b))
assert_equal(-7, (-a).remainder(b))
assert_equal(-7, (-a).remainder(-b))
assert(10**40+10**20 == 10000000000000000000100000000000000000000)
assert(10**40/10**20 == 100000000000000000000)
assert_equal(10**40+10**20, 10000000000000000000100000000000000000000)
assert_equal(10**40/10**20, 100000000000000000000)
a = 677330545177305025495135714080
b = 14269972710765292560
assert(a % b == 0)
assert(-a % b == 0)
assert_equal(a % b, 0)
assert_equal(-a % b, 0)
end
def test_shift
def shift_test(a)
b = a / (2 ** 32)
c = a >> 32
assert(b == c)
assert_equal(b, c)
b = a * (2 ** 32)
c = a << 32
assert(b == c)
assert_equal(b, c)
end
shift_test(-4518325415524767873)

8
test/ruby/test_call.rb
View file

@ -24,9 +24,9 @@ class TestCall < Test::Unit::TestCase
assert(true)
end
assert(aaa(1) == [1, 100])
assert(aaa(1, 2) == [1, 2])
assert(aaa(1, 2, 3, 4) == [1, 2, 3, 4])
assert(aaa(1, *[2, 3, 4]) == [1, 2, 3, 4])
assert_equal(aaa(1), [1, 100])
assert_equal(aaa(1, 2), [1, 2])
assert_equal(aaa(1, 2, 3, 4), [1, 2, 3, 4])
assert_equal(aaa(1, *[2, 3, 4]), [1, 2, 3, 4])
end
end

8
test/ruby/test_clone.rb
View file

@ -19,9 +19,9 @@ class TestClone < Test::Unit::TestCase
"test2"
end
assert(bar.test2 == "test2")
assert(bar.test == "test")
assert(foo.test == "test")
assert_equal(bar.test2, "test2")
assert_equal(bar.test, "test")
assert_equal(foo.test, "test")
begin
foo.test2
@ -30,6 +30,6 @@ class TestClone < Test::Unit::TestCase
assert true
end
assert(M003.ancestors == [M003, M002, M001])
assert_equal(M003.ancestors, [M003, M002, M001])
end
end

10
test/ruby/test_const.rb
View file

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

4
test/ruby/test_defined.rb
View file

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

48
test/ruby/test_eval.rb
View file

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

26
test/ruby/test_float.rb
View file

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

44
test/ruby/test_hash.rb
View file

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

4
test/ruby/test_iterator.rb
View file

@ -239,13 +239,13 @@ class TestIterator < Test::Unit::TestCase
block = get_block{11}
assert_instance_of(Proc, block)
assert_instance_of(Proc, block.to_proc)
assert(block.clone.call == 11)
assert_equal(block.clone.call, 11)
assert_instance_of(Proc, get_block(&block))
lambda = lambda{44}
assert_instance_of(Proc, lambda)
assert_instance_of(Proc, lambda.to_proc)
assert(lambda.clone.call == 44)
assert_equal(lambda.clone.call, 44)
assert_instance_of(Proc, get_block(&lambda))
assert_equal(1, Proc.new{|a,| a}.call(1,2,3))

2
test/ruby/test_marshal.rb
View file

@ -26,7 +26,7 @@ class TestMarshal < Test::Unit::TestCase
a = (x.to_f + y.to_f / z.to_f) * Math.exp(w.to_f / (x.to_f + y.to_f / z.to_f))
ma = Marshal.dump(a)
b = Marshal.load(ma)
assert(a == b)
assert_equal(a, b)
}
end
end

4
test/ruby/test_math.rb
View file

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

6
test/ruby/test_pack.rb
View file

@ -11,11 +11,11 @@ class TestPack < Test::Unit::TestCase
$x = ary.pack($format)
ary2 = $x.unpack($format)
assert(ary.length == ary2.length)
assert(ary.join(':') == ary2.join(':'))
assert_equal(ary.length, ary2.length)
assert_equal(ary.join(':'), ary2.join(':'))
assert($x =~ /def/)
$x = [-1073741825]
assert($x.pack("q").unpack("q") == $x)
assert_equal($x.pack("q").unpack("q"), $x)
end
end

54
test/ruby/test_path.rb
View file

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

10
test/ruby/test_proc.rb
View file

@ -5,12 +5,12 @@ $KCODE = 'none'
class TestProc < Test::Unit::TestCase
def test_proc
$proc = proc{|i| i}
assert($proc.call(2) == 2)
assert($proc.call(3) == 3)
assert_equal($proc.call(2), 2)
assert_equal($proc.call(3), 3)
$proc = proc{|i| i*2}
assert($proc.call(2) == 4)
assert($proc.call(3) == 6)
assert_equal($proc.call(2), 4)
assert_equal($proc.call(3), 6)
proc{
iii=5 # nested local variable
@ -40,6 +40,6 @@ class TestProc < Test::Unit::TestCase
$x=0
$proc.call(5)
$proc2.call
assert($x == 5)
assert_equal($x, 5)
end
end

2
test/ruby/test_signal.rb
View file

@ -9,7 +9,7 @@ class TestSignal < Test::Unit::TestCase
trap "SIGINT", proc{|sig| $x = 2}
Process.kill "SIGINT", $$
sleep 0.1
assert($x == 2)
assert_equal($x, 2)
trap "SIGINT", proc{raise "Interrupt"}

86
test/ruby/test_stringchar.rb
View file

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

6
test/ruby/test_struct.rb
View file

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

14
test/ruby/test_system.rb
View file

@ -9,22 +9,22 @@ class TestSystem < Test::Unit::TestCase
else
ruby = "ruby"
end
assert(`echo foobar` == "foobar\n")
assert(`#{ruby} -e 'print "foobar"'` == 'foobar')
assert_equal(`echo foobar`, "foobar\n")
assert_equal(`#{ruby} -e 'print "foobar"'`, 'foobar')
tmp = open("script_tmp", "w")
tmp.print "print $zzz\n";
tmp.close
assert(`#{ruby} -s script_tmp -zzz` == 'true')
assert(`#{ruby} -s script_tmp -zzz=555` == '555')
assert_equal(`#{ruby} -s script_tmp -zzz`, 'true')
assert_equal(`#{ruby} -s script_tmp -zzz=555`, '555')
tmp = open("script_tmp", "w")
tmp.print "#! /usr/local/bin/ruby -s\n";
tmp.print "print $zzz\n";
tmp.close
assert(`#{ruby} script_tmp -zzz=678` == '678')
assert_equal(`#{ruby} script_tmp -zzz=678`, '678')
tmp = open("script_tmp", "w")
tmp.print "this is a leading junk\n";
@ -34,8 +34,8 @@ class TestSystem < Test::Unit::TestCase
tmp.print "this is a trailing junk\n";
tmp.close
assert(`#{ruby} -x script_tmp` == 'nil')
assert(`#{ruby} -x script_tmp -zzz=555` == '555')
assert_equal(`#{ruby} -x script_tmp`, 'nil')
assert_equal(`#{ruby} -x script_tmp -zzz=555`, '555')
tmp = open("script_tmp", "w")
for i in 1..5

4
test/ruby/test_trace.rb
View file

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

16
test/ruby/test_variable.rb
View file

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

2
test/ruby/test_whileuntil.rb
View file

@ -54,7 +54,7 @@ class TestWhileuntil < Test::Unit::TestCase
redo
end
end
assert(sum == 220)
assert_equal(sum, 220)
$bad = false
tmp = open("while_tmp", "r")