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

* ext/syck/rubyext.c: get rid of warnings.

Browse source 
* lib/rss/taxonomy.rb: ditto.

* lib/rdoc/ri/ri_formatter.rb: ditto.

* test/ruby/test_assignment.rb: ditto.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@5882 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nobu 2004-03-03 23:08:45 +00:00
parent 5dfa7cacd1
commit 9778625be8
5 changed files with 192 additions and 166 deletions
Download patch file Download diff file Expand all files Collapse all files

273
test/ruby/test_assignment.rb
View file

@ -86,155 +86,155 @@ class TestAssignment < Test::Unit::TestCase
end
def test_yield
def f; yield nil; end; f {|a| assert_nil(a)}
def f; yield 1; end; f {|a| assert_equal(1, a)}
def f; yield []; end; f {|a| assert_equal([], a)}
def f; yield [1]; end; f {|a| assert_equal([1], a)}
def f; yield [nil]; end; f {|a| assert_equal([nil], a)}
def f; yield [[]]; end; f {|a| assert_equal([[]], a)}
def f; yield [*[]]; end; f {|a| assert_equal([], a)}
def f; yield [*[1]]; end; f {|a| assert_equal([1], a)}
def f; yield [*[1,2]]; end; f {|a| assert_equal([1,2], a)}
def f; yield(nil); end; f {|a| assert_nil(a)}; undef f
def f; yield(1); end; f {|a| assert_equal(1, a)}; undef f
def f; yield([]); end; f {|a| assert_equal([], a)}; undef f
def f; yield([1]); end; f {|a| assert_equal([1], a)}; undef f
def f; yield([nil]); end; f {|a| assert_equal([nil], a)}; undef f
def f; yield([[]]); end; f {|a| assert_equal([[]], a)}; undef f
def f; yield([*[]]); end; f {|a| assert_equal([], a)}; undef f
def f; yield([*[1]]); end; f {|a| assert_equal([1], a)}; undef f
def f; yield([*[1,2]]); end; f {|a| assert_equal([1,2], a)}; undef f
def f; yield *nil; end; f {|a| assert_nil(a)}
def f; yield *1; end; f {|a| assert_equal(1, a)}
def f; yield *[1]; end; f {|a| assert_equal(1, a)}
def f; yield *[nil]; end; f {|a| assert_nil(a)}
def f; yield *[[]]; end; f {|a| assert_equal([], a)}
def f; yield *[*[1]]; end; f {|a| assert_equal(1, a)}
def f; yield(*nil); end; f {|a| assert_nil(a)}; undef f
def f; yield(*1); end; f {|a| assert_equal(1, a)}; undef f
def f; yield(*[1]); end; f {|a| assert_equal(1, a)}; undef f
def f; yield(*[nil]); end; f {|a| assert_nil(a)}; undef f
def f; yield(*[[]]); end; f {|a| assert_equal([], a)}; undef f
def f; yield(*[*[1]]); end; f {|a| assert_equal(1, a)}; undef f
def f; yield; end; f {|*a| assert_equal([], a)}
def f; yield nil; end; f {|*a| assert_equal([nil], a)}
def f; yield 1; end; f {|*a| assert_equal([1], a)}
def f; yield []; end; f {|*a| assert_equal([[]], a)}
def f; yield [1]; end; f {|*a| assert_equal([[1]], a)}
def f; yield [nil]; end; f {|*a| assert_equal([[nil]], a)}
def f; yield [[]]; end; f {|*a| assert_equal([[[]]], a)}
def f; yield [1,2]; end; f {|*a| assert_equal([[1,2]], a)}
def f; yield [*[]]; end; f {|*a| assert_equal([[]], a)}
def f; yield [*[1]]; end; f {|*a| assert_equal([[1]], a)}
def f; yield [*[1,2]]; end; f {|*a| assert_equal([[1,2]], a)}
def f; yield; end; f {|*a| assert_equal([], a)}; undef f
def f; yield(nil); end; f {|*a| assert_equal([nil], a)}; undef f
def f; yield(1); end; f {|*a| assert_equal([1], a)}; undef f
def f; yield([]); end; f {|*a| assert_equal([[]], a)}; undef f
def f; yield([1]); end; f {|*a| assert_equal([[1]], a)}; undef f
def f; yield([nil]); end; f {|*a| assert_equal([[nil]], a)}; undef f
def f; yield([[]]); end; f {|*a| assert_equal([[[]]], a)}; undef f
def f; yield([1,2]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
def f; yield([*[]]); end; f {|*a| assert_equal([[]], a)}; undef f
def f; yield([*[1]]); end; f {|*a| assert_equal([[1]], a)}; undef f
def f; yield([*[1,2]]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
def f; yield *nil; end; f {|*a| assert_equal([nil], a)}
def f; yield *1; end; f {|*a| assert_equal([1], a)}
def f; yield *[]; end; f {|*a| assert_equal([], a)}
def f; yield *[1]; end; f {|*a| assert_equal([1], a)}
def f; yield *[nil]; end; f {|*a| assert_equal([nil], a)}
def f; yield *[[]]; end; f {|*a| assert_equal([[]], a)}
def f; yield *[*[]]; end; f {|*a| assert_equal([], a)}
def f; yield *[*[1]]; end; f {|*a| assert_equal([1], a)}
def f; yield *[*[1,2]]; end; f {|*a| assert_equal([1,2], a)}
def f; yield(*nil); end; f {|*a| assert_equal([nil], a)}; undef f
def f; yield(*1); end; f {|*a| assert_equal([1], a)}; undef f
def f; yield(*[]); end; f {|*a| assert_equal([], a)}; undef f
def f; yield(*[1]); end; f {|*a| assert_equal([1], a)}; undef f
def f; yield(*[nil]); end; f {|*a| assert_equal([nil], a)}; undef f
def f; yield(*[[]]); end; f {|*a| assert_equal([[]], a)}; undef f
def f; yield(*[*[]]); end; f {|*a| assert_equal([], a)}; undef f
def f; yield(*[*[1]]); end; f {|*a| assert_equal([1], a)}; undef f
def f; yield(*[*[1,2]]); end; f {|*a| assert_equal([1,2], a)}; undef f
def f; yield; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield 1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
def f; yield []; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield [1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
def f; yield [nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield [[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
def f; yield [*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}
def f; yield; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield(nil); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield(1); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
def f; yield([]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield([1]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
def f; yield([nil]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield([[]]); end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}; undef f
def f; yield([*[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield([*[1]]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
def f; yield([*[1,2]]); end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}; undef f
def f; yield *nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield *1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
def f; yield *[]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield *[1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
def f; yield *[nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield *[[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
def f; yield *[*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
def f; yield *[*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
def f; yield *[*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}
def f; yield(*nil); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield(*1); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
def f; yield(*[]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield(*[1]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
def f; yield(*[nil]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield(*[[]]); end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}; undef f
def f; yield(*[*[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
def f; yield(*[*[1]]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
def f; yield(*[*[1,2]]); end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}; undef f
end
def test_return
def r; return; end; a = r(); assert_nil(a)
def r; return nil; end; a = r(); assert_nil(a)
def r; return 1; end; a = r(); assert_equal(1, a)
def r; return []; end; a = r(); assert_equal([], a)
def r; return [1]; end; a = r(); assert_equal([1], a)
def r; return [nil]; end; a = r(); assert_equal([nil], a)
def r; return [[]]; end; a = r(); assert_equal([[]], a)
def r; return [*[]]; end; a = r(); assert_equal([], a)
def r; return [*[1]]; end; a = r(); assert_equal([1], a)
def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a)
def r; return; end; a = r(); assert_nil(a); undef r
def r; return nil; end; a = r(); assert_nil(a); undef r
def r; return 1; end; a = r(); assert_equal(1, a); undef r
def r; return []; end; a = r(); assert_equal([], a); undef r
def r; return [1]; end; a = r(); assert_equal([1], a); undef r
def r; return [nil]; end; a = r(); assert_equal([nil], a); undef r
def r; return [[]]; end; a = r(); assert_equal([[]], a); undef r
def r; return [*[]]; end; a = r(); assert_equal([], a); undef r
def r; return [*[1]]; end; a = r(); assert_equal([1], a); undef r
def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
def r; return *nil; end; a = r(); assert_nil(a)
def r; return *1; end; a = r(); assert_equal(1, a)
def r; return *[]; end; a = r(); assert_nil(a)
def r; return *[1]; end; a = r(); assert_equal(1, a)
def r; return *[nil]; end; a = r(); assert_nil(a)
def r; return *[[]]; end; a = r(); assert_equal([], a)
def r; return *[*[]]; end; a = r(); assert_nil(a)
def r; return *[*[1]]; end; a = r(); assert_equal(1, a)
def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a)
def r; return *nil; end; a = r(); assert_nil(a); undef r
def r; return *1; end; a = r(); assert_equal(1, a); undef r
def r; return *[]; end; a = r(); assert_nil(a); undef r
def r; return *[1]; end; a = r(); assert_equal(1, a); undef r
def r; return *[nil]; end; a = r(); assert_nil(a); undef r
def r; return *[[]]; end; a = r(); assert_equal([], a); undef r
def r; return *[*[]]; end; a = r(); assert_nil(a); undef r
def r; return *[*[1]]; end; a = r(); assert_equal(1, a); undef r
def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
def r; return *nil; end; a = *r(); assert_nil(a)
def r; return *1; end; a = *r(); assert_equal(1, a)
def r; return *[]; end; a = *r(); assert_nil(a)
def r; return *[1]; end; a = *r(); assert_equal(1, a)
def r; return *[nil]; end; a = *r(); assert_nil(a)
def r; return *[[]]; end; a = *r(); assert_nil(a)
def r; return *[*[]]; end; a = *r(); assert_nil(a)
def r; return *[*[1]]; end; a = *r(); assert_equal(1, a)
def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a)
def r; return *nil; end; a = *r(); assert_nil(a); undef r
def r; return *1; end; a = *r(); assert_equal(1, a); undef r
def r; return *[]; end; a = *r(); assert_nil(a); undef r
def r; return *[1]; end; a = *r(); assert_equal(1, a); undef r
def r; return *[nil]; end; a = *r(); assert_nil(a); undef r
def r; return *[[]]; end; a = *r(); assert_nil(a); undef r
def r; return *[*[]]; end; a = *r(); assert_nil(a); undef r
def r; return *[*[1]]; end; a = *r(); assert_equal(1, a); undef r
def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a); undef r
def r; return; end; *a = r(); assert_equal([nil], a)
def r; return nil; end; *a = r(); assert_equal([nil], a)
def r; return 1; end; *a = r(); assert_equal([1], a)
def r; return []; end; *a = r(); assert_equal([[]], a)
def r; return [1]; end; *a = r(); assert_equal([[1]], a)
def r; return [nil]; end; *a = r(); assert_equal([[nil]], a)
def r; return [[]]; end; *a = r(); assert_equal([[[]]], a)
def r; return [1,2]; end; *a = r(); assert_equal([[1,2]], a)
def r; return [*[]]; end; *a = r(); assert_equal([[]], a)
def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a)
def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a)
def r; return; end; *a = r(); assert_equal([nil], a); undef r
def r; return nil; end; *a = r(); assert_equal([nil], a); undef r
def r; return 1; end; *a = r(); assert_equal([1], a); undef r
def r; return []; end; *a = r(); assert_equal([[]], a); undef r
def r; return [1]; end; *a = r(); assert_equal([[1]], a); undef r
def r; return [nil]; end; *a = r(); assert_equal([[nil]], a); undef r
def r; return [[]]; end; *a = r(); assert_equal([[[]]], a); undef r
def r; return [1,2]; end; *a = r(); assert_equal([[1,2]], a); undef r
def r; return [*[]]; end; *a = r(); assert_equal([[]], a); undef r
def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a); undef r
def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a); undef r
def r; return *nil; end; *a = r(); assert_equal([nil], a)
def r; return *1; end; *a = r(); assert_equal([1], a)
def r; return *[]; end; *a = r(); assert_equal([nil], a)
def r; return *[1]; end; *a = r(); assert_equal([1], a)
def r; return *[nil]; end; *a = r(); assert_equal([nil], a)
def r; return *[[]]; end; *a = r(); assert_equal([[]], a)
def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a)
def r; return *[*[]]; end; *a = r(); assert_equal([nil], a)
def r; return *[*[1]]; end; *a = r(); assert_equal([1], a)
def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a)
def r; return *nil; end; *a = r(); assert_equal([nil], a); undef r
def r; return *1; end; *a = r(); assert_equal([1], a); undef r
def r; return *[]; end; *a = r(); assert_equal([nil], a); undef r
def r; return *[1]; end; *a = r(); assert_equal([1], a); undef r
def r; return *[nil]; end; *a = r(); assert_equal([nil], a); undef r
def r; return *[[]]; end; *a = r(); assert_equal([[]], a); undef r
def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a); undef r
def r; return *[*[]]; end; *a = r(); assert_equal([nil], a); undef r
def r; return *[*[1]]; end; *a = r(); assert_equal([1], a); undef r
def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a); undef r
def r; return *nil; end; *a = *r(); assert_equal([nil], a)
def r; return *1; end; *a = *r(); assert_equal([1], a)
def r; return *[]; end; *a = *r(); assert_equal([nil], a)
def r; return *[1]; end; *a = *r(); assert_equal([1], a)
def r; return *[nil]; end; *a = *r(); assert_equal([nil], a)
def r; return *[[]]; end; *a = *r(); assert_equal([], a)
def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a)
def r; return *[*[]]; end; *a = *r(); assert_equal([nil], a)
def r; return *[*[1]]; end; *a = *r(); assert_equal([1], a)
def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a)
def r; return *nil; end; *a = *r(); assert_equal([nil], a); undef r
def r; return *1; end; *a = *r(); assert_equal([1], a); undef r
def r; return *[]; end; *a = *r(); assert_equal([nil], a); undef r
def r; return *[1]; end; *a = *r(); assert_equal([1], a); undef r
def r; return *[nil]; end; *a = *r(); assert_equal([nil], a); undef r
def r; return *[[]]; end; *a = *r(); assert_equal([], a); undef r
def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a); undef r
def r; return *[*[]]; end; *a = *r(); assert_equal([nil], a); undef r
def r; return *[*[1]]; end; *a = *r(); assert_equal([1], a); undef r
def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a); undef r
def r; return; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return 1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
def r; return []; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return [1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
def r; return [nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return [[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c])
def r; return [1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
def r; return [*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return [*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
def r; return; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return 1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return []; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return [1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return [nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return [[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c]); undef r
def r; return [1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
def r; return [*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return [*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
def r; return *nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return *1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return *[[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
def r; return *nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *[[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
end
def test_lambda
@ -382,6 +382,7 @@ class TestAssignment < Test::Unit::TestCase
r(nil){next *[*[]]}
r(1){next *[*[1]]}
r([1,2]){next *[*[1,2]]}
undef r
def r(val); *a = yield(); assert_equal(val, a); end
r([nil]){next}
@ -395,6 +396,7 @@ class TestAssignment < Test::Unit::TestCase
r([[]]){next [*[]]}
r([[1]]){next [*[1]]}
r([[1,2]]){next [*[1,2]]}
undef r
def r(val); *a = *yield(); assert_equal(val, a); end
r([nil]){next *nil}
@ -407,6 +409,7 @@ class TestAssignment < Test::Unit::TestCase
r([nil]){next *[*[]]}
r([1]){next *[*[1]]}
r([1,2]){next *[*[1,2]]}
undef r
def r(val); a,b,*c = yield(); assert_equal(val, [a,b,c]); end
r([nil,nil,[]]){next}
@ -420,6 +423,7 @@ class TestAssignment < Test::Unit::TestCase
r([nil,nil,[]]){next [*[]]}
r([1,nil,[]]){next [*[1]]}
r([1,2,[]]){next [*[1,2]]}
undef r
def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end
r([nil,nil,[]]){next *nil}
@ -432,6 +436,7 @@ class TestAssignment < Test::Unit::TestCase
r([nil,nil,[]]){next *[*[]]}
r([1,nil,[]]){next *[*[1]]}
r([1,2,[]]){next *[*[1,2]]}
undef r
end
def test_assign2