mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
* lib/optparse.rb (OptionParser#order, #permute, #parse): allow an
array as argument. * test/ruby/test_*.rb: moved invariants to left side in assert_equal, and use assert_nil, assert_raises and so on. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@4516 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
nobu
parent
01e3a55648
commit
44785befea
32 changed files with 789 additions and 803 deletions
|
|
@ -5,275 +5,275 @@ $KCODE = 'none'
|
|||
class TestAssignment < Test::Unit::TestCase
|
||||
def test_assign
|
||||
a=[]; a[0] ||= "bar";
|
||||
assert_equal(a[0], "bar")
|
||||
assert_equal("bar", a[0])
|
||||
h={}; h["foo"] ||= "bar";
|
||||
assert_equal(h["foo"], "bar")
|
||||
|
||||
assert_equal("bar", h["foo"])
|
||||
|
||||
aa = 5
|
||||
aa ||= 25
|
||||
assert_equal(aa, 5)
|
||||
assert_equal(5, aa)
|
||||
bb ||= 25
|
||||
assert_equal(bb, 25)
|
||||
assert_equal(25, bb)
|
||||
cc &&=33
|
||||
assert_equal(cc, nil)
|
||||
assert_nil(cc)
|
||||
cc = 5
|
||||
cc &&=44
|
||||
assert_equal(cc, 44)
|
||||
|
||||
a = nil; assert_equal(a, nil)
|
||||
a = 1; assert_equal(a, 1)
|
||||
a = []; assert_equal(a, [])
|
||||
a = [1]; assert_equal(a, [1])
|
||||
a = [nil]; assert_equal(a, [nil])
|
||||
a = [[]]; assert_equal(a, [[]])
|
||||
a = [1,2]; assert_equal(a, [1,2])
|
||||
a = [*[]]; assert_equal(a, [])
|
||||
a = [*[1]]; assert_equal(a, [1])
|
||||
a = [*[1,2]]; assert_equal(a, [1,2])
|
||||
|
||||
a = *nil; assert_equal(a, nil)
|
||||
a = *1; assert_equal(a, 1)
|
||||
a = *[]; assert_equal(a, nil)
|
||||
a = *[1]; assert_equal(a, 1)
|
||||
a = *[nil]; assert_equal(a, nil)
|
||||
a = *[[]]; assert_equal(a, [])
|
||||
a = *[1,2]; assert_equal(a, [1,2])
|
||||
a = *[*[]]; assert_equal(a, nil)
|
||||
a = *[*[1]]; assert_equal(a, 1)
|
||||
a = *[*[1,2]]; assert_equal(a, [1,2])
|
||||
|
||||
*a = nil; assert_equal(a, [nil])
|
||||
*a = 1; assert_equal(a, [1])
|
||||
*a = []; assert_equal(a, [[]])
|
||||
*a = [1]; assert_equal(a, [[1]])
|
||||
*a = [nil]; assert_equal(a, [[nil]])
|
||||
*a = [[]]; assert_equal(a, [[[]]])
|
||||
*a = [1,2]; assert_equal(a, [[1,2]])
|
||||
*a = [*[]]; assert_equal(a, [[]])
|
||||
*a = [*[1]]; assert_equal(a, [[1]])
|
||||
*a = [*[1,2]]; assert_equal(a, [[1,2]])
|
||||
|
||||
*a = *nil; assert_equal(a, [nil])
|
||||
*a = *1; assert_equal(a, [1])
|
||||
*a = *[]; assert_equal(a, [])
|
||||
*a = *[1]; assert_equal(a, [1])
|
||||
*a = *[nil]; assert_equal(a, [nil])
|
||||
*a = *[[]]; assert_equal(a, [[]])
|
||||
*a = *[1,2]; assert_equal(a, [1,2])
|
||||
*a = *[*[]]; assert_equal(a, [])
|
||||
*a = *[*[1]]; assert_equal(a, [1])
|
||||
*a = *[*[1,2]]; assert_equal(a, [1,2])
|
||||
|
||||
a,b,*c = nil; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = 1; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = []; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = [1]; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = [nil]; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = [[]]; assert_equal([a,b,c], [[],nil,[]])
|
||||
a,b,*c = [1,2]; assert_equal([a,b,c], [1,2,[]])
|
||||
a,b,*c = [*[]]; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = [*[1]]; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = [*[1,2]]; assert_equal([a,b,c], [1,2,[]])
|
||||
|
||||
a,b,*c = *nil; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = *1; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = *[]; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = *[1]; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = *[nil]; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = *[[]]; assert_equal([a,b,c], [[],nil,[]])
|
||||
a,b,*c = *[1,2]; assert_equal([a,b,c], [1,2,[]])
|
||||
a,b,*c = *[*[]]; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = *[*[1]]; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = *[*[1,2]]; assert_equal([a,b,c], [1,2,[]])
|
||||
assert_equal(44, cc)
|
||||
|
||||
a = nil; assert_nil(a)
|
||||
a = 1; assert_equal(1, a)
|
||||
a = []; assert_equal([], a)
|
||||
a = [1]; assert_equal([1], a)
|
||||
a = [nil]; assert_equal([nil], a)
|
||||
a = [[]]; assert_equal([[]], a)
|
||||
a = [1,2]; assert_equal([1,2], a)
|
||||
a = [*[]]; assert_equal([], a)
|
||||
a = [*[1]]; assert_equal([1], a)
|
||||
a = [*[1,2]]; assert_equal([1,2], a)
|
||||
|
||||
a = *nil; assert_nil(a)
|
||||
a = *1; assert_equal(1, a)
|
||||
a = *[]; assert_nil(a)
|
||||
a = *[1]; assert_equal(1, a)
|
||||
a = *[nil]; assert_nil(a)
|
||||
a = *[[]]; assert_equal([], a)
|
||||
a = *[1,2]; assert_equal([1,2], a)
|
||||
a = *[*[]]; assert_nil(a)
|
||||
a = *[*[1]]; assert_equal(1, a)
|
||||
a = *[*[1,2]]; assert_equal([1,2], a)
|
||||
|
||||
*a = nil; assert_equal([nil], a)
|
||||
*a = 1; assert_equal([1], a)
|
||||
*a = []; assert_equal([[]], a)
|
||||
*a = [1]; assert_equal([[1]], a)
|
||||
*a = [nil]; assert_equal([[nil]], a)
|
||||
*a = [[]]; assert_equal([[[]]], a)
|
||||
*a = [1,2]; assert_equal([[1,2]], a)
|
||||
*a = [*[]]; assert_equal([[]], a)
|
||||
*a = [*[1]]; assert_equal([[1]], a)
|
||||
*a = [*[1,2]]; assert_equal([[1,2]], a)
|
||||
|
||||
*a = *nil; assert_equal([nil], a)
|
||||
*a = *1; assert_equal([1], a)
|
||||
*a = *[]; assert_equal([], a)
|
||||
*a = *[1]; assert_equal([1], a)
|
||||
*a = *[nil]; assert_equal([nil], a)
|
||||
*a = *[[]]; assert_equal([[]], a)
|
||||
*a = *[1,2]; assert_equal([1,2], a)
|
||||
*a = *[*[]]; assert_equal([], a)
|
||||
*a = *[*[1]]; assert_equal([1], a)
|
||||
*a = *[*[1,2]]; assert_equal([1,2], a)
|
||||
|
||||
a,b,*c = nil; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = 1; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = []; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = [1]; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = [nil]; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = [[]]; assert_equal([[],nil,[]], [a,b,c])
|
||||
a,b,*c = [1,2]; assert_equal([1,2,[]], [a,b,c])
|
||||
a,b,*c = [*[]]; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = [*[1]]; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = [*[1,2]]; assert_equal([1,2,[]], [a,b,c])
|
||||
|
||||
a,b,*c = *nil; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = *1; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = *[]; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = *[1]; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = *[nil]; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = *[[]]; assert_equal([[],nil,[]], [a,b,c])
|
||||
a,b,*c = *[1,2]; assert_equal([1,2,[]], [a,b,c])
|
||||
a,b,*c = *[*[]]; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = *[*[1]]; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = *[*[1,2]]; assert_equal([1,2,[]], [a,b,c])
|
||||
end
|
||||
|
||||
def test_yield
|
||||
def f; yield nil; end; f {|a| assert_equal(a, nil)}
|
||||
def f; yield 1; end; f {|a| assert_equal(a, 1)}
|
||||
def f; yield []; end; f {|a| assert_equal(a, [])}
|
||||
def f; yield [1]; end; f {|a| assert_equal(a, [1])}
|
||||
def f; yield [nil]; end; f {|a| assert_equal(a, [nil])}
|
||||
def f; yield [[]]; end; f {|a| assert_equal(a, [[]])}
|
||||
def f; yield [*[]]; end; f {|a| assert_equal(a, [])}
|
||||
def f; yield [*[1]]; end; f {|a| assert_equal(a, [1])}
|
||||
def f; yield [*[1,2]]; end; f {|a| assert_equal(a, [1,2])}
|
||||
|
||||
def f; yield *nil; end; f {|a| assert_equal(a, nil)}
|
||||
def f; yield *1; end; f {|a| assert_equal(a, 1)}
|
||||
def f; yield *[1]; end; f {|a| assert_equal(a, 1)}
|
||||
def f; yield *[nil]; end; f {|a| assert_equal(a, nil)}
|
||||
def f; yield *[[]]; end; f {|a| assert_equal(a, [])}
|
||||
def f; yield *[*[1]]; end; f {|a| assert_equal(a, 1)}
|
||||
|
||||
def f; yield; end; f {|*a| assert_equal(a, [])}
|
||||
def f; yield nil; end; f {|*a| assert_equal(a, [nil])}
|
||||
def f; yield 1; end; f {|*a| assert_equal(a, [1])}
|
||||
def f; yield []; end; f {|*a| assert_equal(a, [[]])}
|
||||
def f; yield [1]; end; f {|*a| assert_equal(a, [[1]])}
|
||||
def f; yield [nil]; end; f {|*a| assert_equal(a, [[nil]])}
|
||||
def f; yield [[]]; end; f {|*a| assert_equal(a, [[[]]])}
|
||||
def f; yield [1,2]; end; f {|*a| assert_equal(a, [[1,2]])}
|
||||
def f; yield [*[]]; end; f {|*a| assert_equal(a, [[]])}
|
||||
def f; yield [*[1]]; end; f {|*a| assert_equal(a, [[1]])}
|
||||
def f; yield [*[1,2]]; end; f {|*a| assert_equal(a, [[1,2]])}
|
||||
|
||||
def f; yield *nil; end; f {|*a| assert_equal(a, [nil])}
|
||||
def f; yield *1; end; f {|*a| assert_equal(a, [1])}
|
||||
def f; yield *[]; end; f {|*a| assert_equal(a, [])}
|
||||
def f; yield *[1]; end; f {|*a| assert_equal(a, [1])}
|
||||
def f; yield *[nil]; end; f {|*a| assert_equal(a, [nil])}
|
||||
def f; yield *[[]]; end; f {|*a| assert_equal(a, [[]])}
|
||||
def f; yield *[*[]]; end; f {|*a| assert_equal(a, [])}
|
||||
def f; yield *[*[1]]; end; f {|*a| assert_equal(a, [1])}
|
||||
def f; yield *[*[1,2]]; end; f {|*a| assert_equal(a, [1,2])}
|
||||
|
||||
def f; yield; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield nil; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield 1; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
|
||||
def f; yield []; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield [1]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
|
||||
def f; yield [nil]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield [[]]; end; f {|a,b,*c| assert_equal([a,b,c], [[],nil,[]])}
|
||||
def f; yield [*[]]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
|
||||
def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,2,[]])}
|
||||
|
||||
def f; yield *nil; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield *1; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
|
||||
def f; yield *[]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield *[1]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
|
||||
def f; yield *[nil]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield *[[]]; end; f {|a,b,*c| assert_equal([a,b,c], [[],nil,[]])}
|
||||
def f; yield *[*[]]; end; f {|a,b,*c| assert_equal([a,b,c], [nil,nil,[]])}
|
||||
def f; yield *[*[1]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,nil,[]])}
|
||||
def f; yield *[*[1,2]]; end; f {|a,b,*c| assert_equal([a,b,c], [1,2,[]])}
|
||||
def f; yield nil; end; f {|a| assert_nil(a)}
|
||||
def f; yield 1; end; f {|a| assert_equal(1, a)}
|
||||
def f; yield []; end; f {|a| assert_equal([], a)}
|
||||
def f; yield [1]; end; f {|a| assert_equal([1], a)}
|
||||
def f; yield [nil]; end; f {|a| assert_equal([nil], a)}
|
||||
def f; yield [[]]; end; f {|a| assert_equal([[]], a)}
|
||||
def f; yield [*[]]; end; f {|a| assert_equal([], a)}
|
||||
def f; yield [*[1]]; end; f {|a| assert_equal([1], a)}
|
||||
def f; yield [*[1,2]]; end; f {|a| assert_equal([1,2], a)}
|
||||
|
||||
def f; yield *nil; end; f {|a| assert_nil(a)}
|
||||
def f; yield *1; end; f {|a| assert_equal(1, a)}
|
||||
def f; yield *[1]; end; f {|a| assert_equal(1, a)}
|
||||
def f; yield *[nil]; end; f {|a| assert_nil(a)}
|
||||
def f; yield *[[]]; end; f {|a| assert_equal([], a)}
|
||||
def f; yield *[*[1]]; end; f {|a| assert_equal(1, a)}
|
||||
|
||||
def f; yield; end; f {|*a| assert_equal([], a)}
|
||||
def f; yield nil; end; f {|*a| assert_equal([nil], a)}
|
||||
def f; yield 1; end; f {|*a| assert_equal([1], a)}
|
||||
def f; yield []; end; f {|*a| assert_equal([[]], a)}
|
||||
def f; yield [1]; end; f {|*a| assert_equal([[1]], a)}
|
||||
def f; yield [nil]; end; f {|*a| assert_equal([[nil]], a)}
|
||||
def f; yield [[]]; end; f {|*a| assert_equal([[[]]], a)}
|
||||
def f; yield [1,2]; end; f {|*a| assert_equal([[1,2]], a)}
|
||||
def f; yield [*[]]; end; f {|*a| assert_equal([[]], a)}
|
||||
def f; yield [*[1]]; end; f {|*a| assert_equal([[1]], a)}
|
||||
def f; yield [*[1,2]]; end; f {|*a| assert_equal([[1,2]], a)}
|
||||
|
||||
def f; yield *nil; end; f {|*a| assert_equal([nil], a)}
|
||||
def f; yield *1; end; f {|*a| assert_equal([1], a)}
|
||||
def f; yield *[]; end; f {|*a| assert_equal([], a)}
|
||||
def f; yield *[1]; end; f {|*a| assert_equal([1], a)}
|
||||
def f; yield *[nil]; end; f {|*a| assert_equal([nil], a)}
|
||||
def f; yield *[[]]; end; f {|*a| assert_equal([[]], a)}
|
||||
def f; yield *[*[]]; end; f {|*a| assert_equal([], a)}
|
||||
def f; yield *[*[1]]; end; f {|*a| assert_equal([1], a)}
|
||||
def f; yield *[*[1,2]]; end; f {|*a| assert_equal([1,2], a)}
|
||||
|
||||
def f; yield; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield 1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
|
||||
def f; yield []; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield [1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
|
||||
def f; yield [nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield [[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
|
||||
def f; yield [*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield [*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
|
||||
def f; yield [*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}
|
||||
|
||||
def f; yield *nil; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield *1; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
|
||||
def f; yield *[]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield *[1]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
|
||||
def f; yield *[nil]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield *[[]]; end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}
|
||||
def f; yield *[*[]]; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}
|
||||
def f; yield *[*[1]]; end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}
|
||||
def f; yield *[*[1,2]]; end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}
|
||||
end
|
||||
|
||||
def test_return
|
||||
def r; return; end; a = r(); assert_equal(a, nil)
|
||||
def r; return nil; end; a = r(); assert_equal(a, nil)
|
||||
def r; return 1; end; a = r(); assert_equal(a, 1)
|
||||
def r; return []; end; a = r(); assert_equal(a, [])
|
||||
def r; return [1]; end; a = r(); assert_equal(a, [1])
|
||||
def r; return [nil]; end; a = r(); assert_equal(a, [nil])
|
||||
def r; return [[]]; end; a = r(); assert_equal(a, [[]])
|
||||
def r; return [*[]]; end; a = r(); assert_equal(a, [])
|
||||
def r; return [*[1]]; end; a = r(); assert_equal(a, [1])
|
||||
def r; return [*[1,2]]; end; a = r(); assert_equal(a, [1,2])
|
||||
|
||||
def r; return *nil; end; a = r(); assert_equal(a, nil)
|
||||
def r; return *1; end; a = r(); assert_equal(a, 1)
|
||||
def r; return *[]; end; a = r(); assert_equal(a, nil)
|
||||
def r; return *[1]; end; a = r(); assert_equal(a, 1)
|
||||
def r; return *[nil]; end; a = r(); assert_equal(a, nil)
|
||||
def r; return *[[]]; end; a = r(); assert_equal(a, [])
|
||||
def r; return *[*[]]; end; a = r(); assert_equal(a, nil)
|
||||
def r; return *[*[1]]; end; a = r(); assert_equal(a, 1)
|
||||
def r; return *[*[1,2]]; end; a = r(); assert_equal(a, [1,2])
|
||||
|
||||
def r; return *nil; end; a = *r(); assert_equal(a, nil)
|
||||
def r; return *1; end; a = *r(); assert_equal(a, 1)
|
||||
def r; return *[]; end; a = *r(); assert_equal(a, nil)
|
||||
def r; return *[1]; end; a = *r(); assert_equal(a, 1)
|
||||
def r; return *[nil]; end; a = *r(); assert_equal(a, nil)
|
||||
def r; return *[[]]; end; a = *r(); assert_equal(a, nil)
|
||||
def r; return *[*[]]; end; a = *r(); assert_equal(a, nil)
|
||||
def r; return *[*[1]]; end; a = *r(); assert_equal(a, 1)
|
||||
def r; return *[*[1,2]]; end; a = *r(); assert_equal(a, [1,2])
|
||||
|
||||
def r; return; end; *a = r(); assert_equal(a, [nil])
|
||||
def r; return nil; end; *a = r(); assert_equal(a, [nil])
|
||||
def r; return 1; end; *a = r(); assert_equal(a, [1])
|
||||
def r; return []; end; *a = r(); assert_equal(a, [[]])
|
||||
def r; return [1]; end; *a = r(); assert_equal(a, [[1]])
|
||||
def r; return [nil]; end; *a = r(); assert_equal(a, [[nil]])
|
||||
def r; return [[]]; end; *a = r(); assert_equal(a, [[[]]])
|
||||
def r; return [1,2]; end; *a = r(); assert_equal(a, [[1,2]])
|
||||
def r; return [*[]]; end; *a = r(); assert_equal(a, [[]])
|
||||
def r; return [*[1]]; end; *a = r(); assert_equal(a, [[1]])
|
||||
def r; return [*[1,2]]; end; *a = r(); assert_equal(a, [[1,2]])
|
||||
|
||||
def r; return *nil; end; *a = r(); assert_equal(a, [nil])
|
||||
def r; return *1; end; *a = r(); assert_equal(a, [1])
|
||||
def r; return *[]; end; *a = r(); assert_equal(a, [nil])
|
||||
def r; return *[1]; end; *a = r(); assert_equal(a, [1])
|
||||
def r; return *[nil]; end; *a = r(); assert_equal(a, [nil])
|
||||
def r; return *[[]]; end; *a = r(); assert_equal(a, [[]])
|
||||
def r; return *[1,2]; end; *a = r(); assert_equal(a, [[1,2]])
|
||||
def r; return *[*[]]; end; *a = r(); assert_equal(a, [nil])
|
||||
def r; return *[*[1]]; end; *a = r(); assert_equal(a, [1])
|
||||
def r; return *[*[1,2]]; end; *a = r(); assert_equal(a, [[1,2]])
|
||||
|
||||
def r; return *nil; end; *a = *r(); assert_equal(a, [nil])
|
||||
def r; return *1; end; *a = *r(); assert_equal(a, [1])
|
||||
def r; return *[]; end; *a = *r(); assert_equal(a, [nil])
|
||||
def r; return *[1]; end; *a = *r(); assert_equal(a, [1])
|
||||
def r; return *[nil]; end; *a = *r(); assert_equal(a, [nil])
|
||||
def r; return *[[]]; end; *a = *r(); assert_equal(a, [])
|
||||
def r; return *[1,2]; end; *a = *r(); assert_equal(a, [1,2])
|
||||
def r; return *[*[]]; end; *a = *r(); assert_equal(a, [nil])
|
||||
def r; return *[*[1]]; end; *a = *r(); assert_equal(a, [1])
|
||||
def r; return *[*[1,2]]; end; *a = *r(); assert_equal(a, [1,2])
|
||||
|
||||
def r; return; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return nil; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return 1; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
|
||||
def r; return []; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return [1]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
|
||||
def r; return [nil]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return [[]]; end; a,b,*c = r(); assert_equal([a,b,c], [[],nil,[]])
|
||||
def r; return [1,2]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
|
||||
def r; return [*[]]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return [*[1]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
|
||||
def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
|
||||
|
||||
def r; return *nil; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return *1; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
|
||||
def r; return *[]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return *[1]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
|
||||
def r; return *[nil]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return *[[]]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return *[1,2]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
|
||||
def r; return *[*[]]; end; a,b,*c = r(); assert_equal([a,b,c], [nil,nil,[]])
|
||||
def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,nil,[]])
|
||||
def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([a,b,c], [1,2,[]])
|
||||
def r; return; end; a = r(); assert_nil(a)
|
||||
def r; return nil; end; a = r(); assert_nil(a)
|
||||
def r; return 1; end; a = r(); assert_equal(1, a)
|
||||
def r; return []; end; a = r(); assert_equal([], a)
|
||||
def r; return [1]; end; a = r(); assert_equal([1], a)
|
||||
def r; return [nil]; end; a = r(); assert_equal([nil], a)
|
||||
def r; return [[]]; end; a = r(); assert_equal([[]], a)
|
||||
def r; return [*[]]; end; a = r(); assert_equal([], a)
|
||||
def r; return [*[1]]; end; a = r(); assert_equal([1], a)
|
||||
def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a)
|
||||
|
||||
def r; return *nil; end; a = r(); assert_nil(a)
|
||||
def r; return *1; end; a = r(); assert_equal(1, a)
|
||||
def r; return *[]; end; a = r(); assert_nil(a)
|
||||
def r; return *[1]; end; a = r(); assert_equal(1, a)
|
||||
def r; return *[nil]; end; a = r(); assert_nil(a)
|
||||
def r; return *[[]]; end; a = r(); assert_equal([], a)
|
||||
def r; return *[*[]]; end; a = r(); assert_nil(a)
|
||||
def r; return *[*[1]]; end; a = r(); assert_equal(1, a)
|
||||
def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a)
|
||||
|
||||
def r; return *nil; end; a = *r(); assert_nil(a)
|
||||
def r; return *1; end; a = *r(); assert_equal(1, a)
|
||||
def r; return *[]; end; a = *r(); assert_nil(a)
|
||||
def r; return *[1]; end; a = *r(); assert_equal(1, a)
|
||||
def r; return *[nil]; end; a = *r(); assert_nil(a)
|
||||
def r; return *[[]]; end; a = *r(); assert_nil(a)
|
||||
def r; return *[*[]]; end; a = *r(); assert_nil(a)
|
||||
def r; return *[*[1]]; end; a = *r(); assert_equal(1, a)
|
||||
def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a)
|
||||
|
||||
def r; return; end; *a = r(); assert_equal([nil], a)
|
||||
def r; return nil; end; *a = r(); assert_equal([nil], a)
|
||||
def r; return 1; end; *a = r(); assert_equal([1], a)
|
||||
def r; return []; end; *a = r(); assert_equal([[]], a)
|
||||
def r; return [1]; end; *a = r(); assert_equal([[1]], a)
|
||||
def r; return [nil]; end; *a = r(); assert_equal([[nil]], a)
|
||||
def r; return [[]]; end; *a = r(); assert_equal([[[]]], a)
|
||||
def r; return [1,2]; end; *a = r(); assert_equal([[1,2]], a)
|
||||
def r; return [*[]]; end; *a = r(); assert_equal([[]], a)
|
||||
def r; return [*[1]]; end; *a = r(); assert_equal([[1]], a)
|
||||
def r; return [*[1,2]]; end; *a = r(); assert_equal([[1,2]], a)
|
||||
|
||||
def r; return *nil; end; *a = r(); assert_equal([nil], a)
|
||||
def r; return *1; end; *a = r(); assert_equal([1], a)
|
||||
def r; return *[]; end; *a = r(); assert_equal([nil], a)
|
||||
def r; return *[1]; end; *a = r(); assert_equal([1], a)
|
||||
def r; return *[nil]; end; *a = r(); assert_equal([nil], a)
|
||||
def r; return *[[]]; end; *a = r(); assert_equal([[]], a)
|
||||
def r; return *[1,2]; end; *a = r(); assert_equal([[1,2]], a)
|
||||
def r; return *[*[]]; end; *a = r(); assert_equal([nil], a)
|
||||
def r; return *[*[1]]; end; *a = r(); assert_equal([1], a)
|
||||
def r; return *[*[1,2]]; end; *a = r(); assert_equal([[1,2]], a)
|
||||
|
||||
def r; return *nil; end; *a = *r(); assert_equal([nil], a)
|
||||
def r; return *1; end; *a = *r(); assert_equal([1], a)
|
||||
def r; return *[]; end; *a = *r(); assert_equal([nil], a)
|
||||
def r; return *[1]; end; *a = *r(); assert_equal([1], a)
|
||||
def r; return *[nil]; end; *a = *r(); assert_equal([nil], a)
|
||||
def r; return *[[]]; end; *a = *r(); assert_equal([], a)
|
||||
def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a)
|
||||
def r; return *[*[]]; end; *a = *r(); assert_equal([nil], a)
|
||||
def r; return *[*[1]]; end; *a = *r(); assert_equal([1], a)
|
||||
def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a)
|
||||
|
||||
def r; return; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return 1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
|
||||
def r; return []; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return [1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
|
||||
def r; return [nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return [[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c])
|
||||
def r; return [1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
|
||||
def r; return [*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return [*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
|
||||
def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
|
||||
|
||||
def r; return *nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return *1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
|
||||
def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
|
||||
def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return *[[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
|
||||
def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c])
|
||||
def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c])
|
||||
def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c])
|
||||
end
|
||||
|
||||
def test_lambda
|
||||
f = lambda {|r,| assert_equal([], r)}
|
||||
f.call([], *[])
|
||||
|
||||
|
||||
f = lambda {|r,*l| assert_equal([], r); assert_equal([1], l)}
|
||||
f.call([], *[1])
|
||||
|
||||
|
||||
f = lambda{|x| x}
|
||||
assert_equal(f.call(42), 42)
|
||||
assert_equal(f.call([42]), [42])
|
||||
assert_equal(f.call([[42]]), [[42]])
|
||||
assert_equal(f.call([42,55]), [42,55])
|
||||
|
||||
assert_equal(42, f.call(42))
|
||||
assert_equal([42], f.call([42]))
|
||||
assert_equal([[42]], f.call([[42]]))
|
||||
assert_equal([42,55], f.call([42,55]))
|
||||
|
||||
f = lambda{|x,| x}
|
||||
assert_equal(f.call(42), 42)
|
||||
assert_equal(f.call([42]), [42])
|
||||
assert_equal(f.call([[42]]), [[42]])
|
||||
assert_equal(f.call([42,55]), [42,55])
|
||||
|
||||
assert_equal(42, f.call(42))
|
||||
assert_equal([42], f.call([42]))
|
||||
assert_equal([[42]], f.call([[42]]))
|
||||
assert_equal([42,55], f.call([42,55]))
|
||||
|
||||
f = lambda{|*x| x}
|
||||
assert_equal(f.call(42), [42])
|
||||
assert_equal(f.call([42]), [[42]])
|
||||
assert_equal(f.call([[42]]), [[[42]]])
|
||||
assert_equal(f.call([42,55]), [[42,55]])
|
||||
assert_equal(f.call(42,55), [42,55])
|
||||
assert_equal([42], f.call(42))
|
||||
assert_equal([[42]], f.call([42]))
|
||||
assert_equal([[[42]]], f.call([[42]]))
|
||||
assert_equal([[42,55]], f.call([42,55]))
|
||||
assert_equal([42,55], f.call(42,55))
|
||||
end
|
||||
|
||||
def test_multi
|
||||
a,=*[1]
|
||||
assert_equal(a, 1)
|
||||
assert_equal(1, a)
|
||||
a,=*[[1]]
|
||||
assert_equal(a, [1])
|
||||
assert_equal([1], a)
|
||||
a,=*[[[1]]]
|
||||
assert_equal(a, [[1]])
|
||||
|
||||
assert_equal([[1]], a)
|
||||
|
||||
x, (y, z) = 1, 2, 3
|
||||
assert_equal([1,2,nil], [x,y,z])
|
||||
x, (y, z) = 1, [2,3]
|
||||
|
|
@ -283,87 +283,87 @@ class TestAssignment < Test::Unit::TestCase
|
|||
end
|
||||
|
||||
def test_break
|
||||
a = loop do break; end; assert_equal(a, nil)
|
||||
a = loop do break nil; end; assert_equal(a, nil)
|
||||
a = loop do break 1; end; assert_equal(a, 1)
|
||||
a = loop do break []; end; assert_equal(a, [])
|
||||
a = loop do break [1]; end; assert_equal(a, [1])
|
||||
a = loop do break [nil]; end; assert_equal(a, [nil])
|
||||
a = loop do break [[]]; end; assert_equal(a, [[]])
|
||||
a = loop do break [*[]]; end; assert_equal(a, [])
|
||||
a = loop do break [*[1]]; end; assert_equal(a, [1])
|
||||
a = loop do break [*[1,2]]; end; assert_equal(a, [1,2])
|
||||
|
||||
a = loop do break *nil; end; assert_equal(a, nil)
|
||||
a = loop do break *1; end; assert_equal(a, 1)
|
||||
a = loop do break *[]; end; assert_equal(a, nil)
|
||||
a = loop do break *[1]; end; assert_equal(a, 1)
|
||||
a = loop do break *[nil]; end; assert_equal(a, nil)
|
||||
a = loop do break *[[]]; end; assert_equal(a, [])
|
||||
a = loop do break *[*[]]; end; assert_equal(a, nil)
|
||||
a = loop do break *[*[1]]; end; assert_equal(a, 1)
|
||||
a = loop do break *[*[1,2]]; end; assert_equal(a, [1,2])
|
||||
|
||||
*a = loop do break; end; assert_equal(a, [nil])
|
||||
*a = loop do break nil; end; assert_equal(a, [nil])
|
||||
*a = loop do break 1; end; assert_equal(a, [1])
|
||||
*a = loop do break []; end; assert_equal(a, [[]])
|
||||
*a = loop do break [1]; end; assert_equal(a, [[1]])
|
||||
*a = loop do break [nil]; end; assert_equal(a, [[nil]])
|
||||
*a = loop do break [[]]; end; assert_equal(a, [[[]]])
|
||||
*a = loop do break [1,2]; end; assert_equal(a, [[1,2]])
|
||||
*a = loop do break [*[]]; end; assert_equal(a, [[]])
|
||||
*a = loop do break [*[1]]; end; assert_equal(a, [[1]])
|
||||
*a = loop do break [*[1,2]]; end; assert_equal(a, [[1,2]])
|
||||
|
||||
*a = loop do break *nil; end; assert_equal(a, [nil])
|
||||
*a = loop do break *1; end; assert_equal(a, [1])
|
||||
*a = loop do break *[]; end; assert_equal(a, [nil])
|
||||
*a = loop do break *[1]; end; assert_equal(a, [1])
|
||||
*a = loop do break *[nil]; end; assert_equal(a, [nil])
|
||||
*a = loop do break *[[]]; end; assert_equal(a, [[]])
|
||||
*a = loop do break *[1,2]; end; assert_equal(a, [[1,2]])
|
||||
*a = loop do break *[*[]]; end; assert_equal(a, [nil])
|
||||
*a = loop do break *[*[1]]; end; assert_equal(a, [1])
|
||||
*a = loop do break *[*[1,2]]; end; assert_equal(a, [[1,2]])
|
||||
|
||||
*a = *loop do break *nil; end; assert_equal(a, [nil])
|
||||
*a = *loop do break *1; end; assert_equal(a, [1])
|
||||
*a = *loop do break *[]; end; assert_equal(a, [nil])
|
||||
*a = *loop do break *[1]; end; assert_equal(a, [1])
|
||||
*a = *loop do break *[nil]; end; assert_equal(a, [nil])
|
||||
*a = *loop do break *[[]]; end; assert_equal(a, [])
|
||||
*a = *loop do break *[1,2]; end; assert_equal(a, [1,2])
|
||||
*a = *loop do break *[*[]]; end; assert_equal(a, [nil])
|
||||
*a = *loop do break *[*[1]]; end; assert_equal(a, [1])
|
||||
*a = *loop do break *[*[1,2]]; end; assert_equal(a, [1,2])
|
||||
|
||||
a,b,*c = loop do break; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break nil; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break 1; end; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = loop do break []; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break [1]; end; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = loop do break [nil]; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break [[]]; end; assert_equal([a,b,c], [[],nil,[]])
|
||||
a,b,*c = loop do break [1,2]; end; assert_equal([a,b,c], [1,2,[]])
|
||||
a,b,*c = loop do break [*[]]; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break [*[1]]; end; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = loop do break [*[1,2]]; end; assert_equal([a,b,c], [1,2,[]])
|
||||
|
||||
a,b,*c = loop do break *nil; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break *1; end; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = loop do break *[]; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break *[1]; end; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = loop do break *[nil]; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break *[[]]; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break *[1,2]; end; assert_equal([a,b,c], [1,2,[]])
|
||||
a,b,*c = loop do break *[*[]]; end; assert_equal([a,b,c], [nil,nil,[]])
|
||||
a,b,*c = loop do break *[*[1]]; end; assert_equal([a,b,c], [1,nil,[]])
|
||||
a,b,*c = loop do break *[*[1,2]]; end; assert_equal([a,b,c], [1,2,[]])
|
||||
a = loop do break; end; assert_nil(a)
|
||||
a = loop do break nil; end; assert_nil(a)
|
||||
a = loop do break 1; end; assert_equal(1, a)
|
||||
a = loop do break []; end; assert_equal([], a)
|
||||
a = loop do break [1]; end; assert_equal([1], a)
|
||||
a = loop do break [nil]; end; assert_equal([nil], a)
|
||||
a = loop do break [[]]; end; assert_equal([[]], a)
|
||||
a = loop do break [*[]]; end; assert_equal([], a)
|
||||
a = loop do break [*[1]]; end; assert_equal([1], a)
|
||||
a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
|
||||
|
||||
a = loop do break *nil; end; assert_nil(a)
|
||||
a = loop do break *1; end; assert_equal(1, a)
|
||||
a = loop do break *[]; end; assert_nil(a)
|
||||
a = loop do break *[1]; end; assert_equal(1, a)
|
||||
a = loop do break *[nil]; end; assert_nil(a)
|
||||
a = loop do break *[[]]; end; assert_equal([], a)
|
||||
a = loop do break *[*[]]; end; assert_nil(a)
|
||||
a = loop do break *[*[1]]; end; assert_equal(1, a)
|
||||
a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
|
||||
|
||||
*a = loop do break; end; assert_equal([nil], a)
|
||||
*a = loop do break nil; end; assert_equal([nil], a)
|
||||
*a = loop do break 1; end; assert_equal([1], a)
|
||||
*a = loop do break []; end; assert_equal([[]], a)
|
||||
*a = loop do break [1]; end; assert_equal([[1]], a)
|
||||
*a = loop do break [nil]; end; assert_equal([[nil]], a)
|
||||
*a = loop do break [[]]; end; assert_equal([[[]]], a)
|
||||
*a = loop do break [1,2]; end; assert_equal([[1,2]], a)
|
||||
*a = loop do break [*[]]; end; assert_equal([[]], a)
|
||||
*a = loop do break [*[1]]; end; assert_equal([[1]], a)
|
||||
*a = loop do break [*[1,2]]; end; assert_equal([[1,2]], a)
|
||||
|
||||
*a = loop do break *nil; end; assert_equal([nil], a)
|
||||
*a = loop do break *1; end; assert_equal([1], a)
|
||||
*a = loop do break *[]; end; assert_equal([nil], a)
|
||||
*a = loop do break *[1]; end; assert_equal([1], a)
|
||||
*a = loop do break *[nil]; end; assert_equal([nil], a)
|
||||
*a = loop do break *[[]]; end; assert_equal([[]], a)
|
||||
*a = loop do break *[1,2]; end; assert_equal([[1,2]], a)
|
||||
*a = loop do break *[*[]]; end; assert_equal([nil], a)
|
||||
*a = loop do break *[*[1]]; end; assert_equal([1], a)
|
||||
*a = loop do break *[*[1,2]]; end; assert_equal([[1,2]], a)
|
||||
|
||||
*a = *loop do break *nil; end; assert_equal([nil], a)
|
||||
*a = *loop do break *1; end; assert_equal([1], a)
|
||||
*a = *loop do break *[]; end; assert_equal([nil], a)
|
||||
*a = *loop do break *[1]; end; assert_equal([1], a)
|
||||
*a = *loop do break *[nil]; end; assert_equal([nil], a)
|
||||
*a = *loop do break *[[]]; end; assert_equal([], a)
|
||||
*a = *loop do break *[1,2]; end; assert_equal([1,2], a)
|
||||
*a = *loop do break *[*[]]; end; assert_equal([nil], a)
|
||||
*a = *loop do break *[*[1]]; end; assert_equal([1], a)
|
||||
*a = *loop do break *[*[1,2]]; end; assert_equal([1,2], a)
|
||||
|
||||
a,b,*c = loop do break; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break nil; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break 1; end; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break []; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break [1]; end; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break [nil]; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break [[]]; end; assert_equal([[],nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break [1,2]; end; assert_equal([1,2,[]], [a,b,c])
|
||||
a,b,*c = loop do break [*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break [*[1]]; end; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break [*[1,2]]; end; assert_equal([1,2,[]], [a,b,c])
|
||||
|
||||
a,b,*c = loop do break *nil; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *1; end; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[]; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[1]; end; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[nil]; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[[]]; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[1,2]; end; assert_equal([1,2,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[*[1]]; end; assert_equal([1,nil,[]], [a,b,c])
|
||||
a,b,*c = loop do break *[*[1,2]]; end; assert_equal([1,2,[]], [a,b,c])
|
||||
end
|
||||
|
||||
def test_next
|
||||
def r(val); a = yield(); assert_equal(a, val); end
|
||||
def r(val); a = yield(); assert_equal(val, a); end
|
||||
r(nil){next}
|
||||
r(nil){next nil}
|
||||
r(1){next 1}
|
||||
|
|
@ -374,7 +374,7 @@ class TestAssignment < Test::Unit::TestCase
|
|||
r([]){next [*[]]}
|
||||
r([1]){next [*[1]]}
|
||||
r([1,2]){next [*[1,2]]}
|
||||
|
||||
|
||||
r(nil){next *nil}
|
||||
r(1){next *1}
|
||||
r(nil){next *[]}
|
||||
|
|
@ -384,8 +384,8 @@ class TestAssignment < Test::Unit::TestCase
|
|||
r(nil){next *[*[]]}
|
||||
r(1){next *[*[1]]}
|
||||
r([1,2]){next *[*[1,2]]}
|
||||
|
||||
def r(val); *a = yield(); assert_equal(a, val); end
|
||||
|
||||
def r(val); *a = yield(); assert_equal(val, a); end
|
||||
r([nil]){next}
|
||||
r([nil]){next nil}
|
||||
r([1]){next 1}
|
||||
|
|
@ -397,8 +397,8 @@ class TestAssignment < Test::Unit::TestCase
|
|||
r([[]]){next [*[]]}
|
||||
r([[1]]){next [*[1]]}
|
||||
r([[1,2]]){next [*[1,2]]}
|
||||
|
||||
def r(val); *a = *yield(); assert_equal(a, val); end
|
||||
|
||||
def r(val); *a = *yield(); assert_equal(val, a); end
|
||||
r([nil]){next *nil}
|
||||
r([1]){next *1}
|
||||
r([nil]){next *[]}
|
||||
|
|
@ -409,8 +409,8 @@ class TestAssignment < Test::Unit::TestCase
|
|||
r([nil]){next *[*[]]}
|
||||
r([1]){next *[*[1]]}
|
||||
r([1,2]){next *[*[1,2]]}
|
||||
|
||||
def r(val); a,b,*c = yield(); assert_equal([a,b,c], val); end
|
||||
|
||||
def r(val); a,b,*c = yield(); assert_equal(val, [a,b,c]); end
|
||||
r([nil,nil,[]]){next}
|
||||
r([nil,nil,[]]){next nil}
|
||||
r([1,nil,[]]){next 1}
|
||||
|
|
@ -422,8 +422,8 @@ class TestAssignment < Test::Unit::TestCase
|
|||
r([nil,nil,[]]){next [*[]]}
|
||||
r([1,nil,[]]){next [*[1]]}
|
||||
r([1,2,[]]){next [*[1,2]]}
|
||||
|
||||
def r(val); a,b,*c = *yield(); assert_equal([a,b,c], val); end
|
||||
|
||||
def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end
|
||||
r([nil,nil,[]]){next *nil}
|
||||
r([1,nil,[]]){next *1}
|
||||
r([nil,nil,[]]){next *[]}
|
||||
|
|
@ -439,31 +439,31 @@ class TestAssignment < Test::Unit::TestCase
|
|||
def test_assign2
|
||||
a = nil
|
||||
assert(defined?(a))
|
||||
assert_equal(a, nil)
|
||||
|
||||
assert_nil(a)
|
||||
|
||||
# multiple asignment
|
||||
a, b = 1, 2
|
||||
assert(a == 1 && b == 2)
|
||||
|
||||
|
||||
a, b = b, a
|
||||
assert(a == 2 && b == 1)
|
||||
|
||||
|
||||
a, = 1,2
|
||||
assert_equal(a, 1)
|
||||
|
||||
assert_equal(1, a)
|
||||
|
||||
a, *b = 1, 2, 3
|
||||
assert(a == 1 && b == [2, 3])
|
||||
|
||||
|
||||
a, (b, c), d = 1, [2, 3], 4
|
||||
assert(a == 1 && b == 2 && c == 3 && d == 4)
|
||||
|
||||
|
||||
*a = 1, 2, 3
|
||||
assert_equal(a, [1, 2, 3])
|
||||
|
||||
assert_equal([1, 2, 3], a)
|
||||
|
||||
*a = 4
|
||||
assert_equal(a, [4])
|
||||
|
||||
assert_equal([4], a)
|
||||
|
||||
*a = nil
|
||||
assert_equal(a, [nil])
|
||||
assert_equal([nil], a)
|
||||
end
|
||||
end
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue