From: Gary Wright <gwtmp01@...>
Date: 2007-02-17T08:41:40+09:00
Subject: Re: [ ruby-Bugs-8679 ] Unexpected behavior of splat (*) in parallel assignment


On Feb 15, 2007, at 2:29 PM, noreply@rubyforge.org wrote:

> Bugs item #8679, was opened at 2007-02-15 14:29
> You can respond by visiting:
> http://rubyforge.org/tracker/? 
> func=detail&atid=1698&aid=8679&group_id=426
>
> Category: Core
> Group: 1.9.x
> Status: Open
> Resolution: None
> Priority: 3
> Submitted By: Gary Wright (gwright)
> Assigned to: Nobody (None)
> Summary: Unexpected behavior of splat (*) in parallel assignment


Here is a patch for test/ruby/test_assignment.rb and
test/ruby/test_array.rb to add cases for this situation.

Index: test/ruby/test_array.rb
===================================================================
--- test/ruby/test_array.rb	(revision 11764)
+++ test/ruby/test_array.rb	(working copy)
@@ -11,6 +11,8 @@
      assert_equal([2,3], [1,2,3] & [2,3,4])
      assert_equal([1,2,3,4], [1,2,3] | [2,3,4])
      assert_equal([1,2,3] - [2,3], [1])
+    assert_equal([1,*[2,3]], [1,2,3])
+    assert_equal([*[1,2],3], [1,2,3])
      x = [0, 1, 2, 3, 4, 5]
      assert_equal(2, x[2])
Index: test/ruby/test_assignment.rb
===================================================================
--- test/ruby/test_assignment.rb	(revision 11764)
+++ test/ruby/test_assignment.rb	(working copy)
@@ -28,6 +28,7 @@
      a = [*[]]; assert_equal([], a)
      a = [*[1]]; assert_equal([1], a)
      a = [*[1,2]]; assert_equal([1,2], a)
+    a = [*[1,2], 3]; assert_equal([1,2,3], a)
      a = *[]; assert_equal([], a)
      a = *[1]; assert_equal([1], a)
@@ -37,6 +38,7 @@
      a = *[*[]]; assert_equal([], a)
      a = *[*[1]]; assert_equal([1], a)
      a = *[*[1,2]]; assert_equal([1,2], a)
+    a = *[*[1,2], 3]; assert_equal([1,2,3], a)
      *a = nil; assert_equal([nil], a)
      *a = 1; assert_equal([1], a)
@@ -48,6 +50,7 @@
      *a = [*[]]; assert_equal([], a)
      *a = [*[1]]; assert_equal([1], a)
      *a = [*[1,2]]; assert_equal([1,2], a)
+    *a = [*[1,2], 3]; assert_equal([1,2,3], a)
      *a = *[]; assert_equal([], a)
      *a = *[1]; assert_equal([1], a)
@@ -57,6 +60,7 @@
      *a = *[*[]]; assert_equal([], a)
      *a = *[*[1]]; assert_equal([1], a)
      *a = *[*[1,2]]; assert_equal([1,2], a)
+    *a = *[*[1,2],3]; assert_equal([1,2,3], a)
      a,b,*c = nil; assert_equal([nil,nil,[]], [a,b,c])
      a,b,*c = 1; assert_equal([1,nil,[]], [a,b,c])
@@ -68,6 +72,7 @@
      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,*d = [*[1,2],3]; assert_equal([1,2,3,[]], [a,b,c,d])
      a,b,*c = *[]; assert_equal([nil,nil,[]], [a,b,c])
      a,b,*c = *[1]; assert_equal([1,nil,[]], [a,b,c])
@@ -77,6 +82,7 @@
      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,*d = *[*[1,2],3]; assert_equal([1,2,3,[]], [a,b,c,d])
    end
    def test_yield
@@ -89,6 +95,7 @@
      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([*[1,2],3]); end; f {|a| assert_equal([1,2,3], 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
@@ -106,6 +113,7 @@
      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([*[1,2],3]); end; f {|*a| assert_equal([1,2,3],  
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
@@ -114,6 +122,7 @@
      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(*[*[1,2],3]); end; f {|*a| assert_equal([1,2,3],  
a)}; undef f
      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
@@ -125,6 +134,7 @@
      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([*[1,2],3]); end; f {|a,b,c,*d| assert_equal([1,2,3, 
[]], [a,b,c,d])}; 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
@@ -133,6 +143,7 @@
      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(*[*[1,2],3]); end; f {|a,b,c,*d| assert_equal 
([1,2,3,[]], [a,b,c,d])}; undef f
    end
    def test_return
@@ -146,6 +157,7 @@
      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 [*[1,2],3]; end; a = r(); assert_equal([1,2,3],  
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
@@ -154,9 +166,11 @@
      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 *[*[1,2],3]; end; a = r(); assert_equal([1,2,3],  
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 *[*[1,2],3]; end; a = *r(); assert_equal([1,2,3],  
a); undef r
      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
@@ -169,6 +183,7 @@
      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 [*[1,2],3]; end; *a = r(); assert_equal([1,2,3],  
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
@@ -178,10 +193,12 @@
      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 *[*[1,2],3]; end; *a = r(); assert_equal([1,2,3],  
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 *[*[1,2]]; end; *a = *r(); assert_equal([1,2],  
a); undef r
+    def r; return *[*[1,2],3]; end; *a = *r(); assert_equal([1,2,3],  
a); undef r
      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
@@ -194,6 +211,7 @@
      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 [*[1,2],3]; end; a,b,c,*d = r(); assert_equal 
([1,2,3,[]], [a,b,c,d]); 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
@@ -203,6 +221,7 @@
      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 *[*[1,2,3]]; end; a,b,c,*d = r(); assert_equal 
([1,2,3,[]], [a,b,c,d]); undef r
    end
    def test_lambda
@@ -246,6 +265,9 @@
      assert_equal([1,2,3], [x,y,z])
      x, (y, z) = 1, [2]
      assert_equal([1,2,nil], [x,y,z])
+
+    x,y,z = [*[1,2],3]
+    assert_equal([1,2,3], [x,y,z])
    end
    def test_break
@@ -259,6 +281,7 @@
      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 [*[1,2],3]; end; assert_equal([1,2,3], a)
      a = loop do break *[]; end; assert_equal([], a)
      a = loop do break *[1]; end; assert_equal([1], a)
@@ -267,6 +290,7 @@
      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 *[*[1,2],3]; end; assert_equal([1,2,3], a)
      *a = loop do break; end; assert_equal([nil], a)
      *a = loop do break nil; end; assert_equal([nil], a)
@@ -279,6 +303,7 @@
      *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 [*[1,2],3]; end; assert_equal([1,2,3], a)
      *a = loop do break *[]; end; assert_equal([], a)
      *a = loop do break *[1]; end; assert_equal([1], a)
@@ -288,10 +313,12 @@
      *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 *[*[1,2],3]; end; assert_equal([1,2,3], 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 *[*[1,2]]; end; assert_equal([1,2], a)
+    *a = *loop do break *[*[1,2],3]; end; assert_equal([1,2,3], 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])
@@ -304,6 +331,7 @@
      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,*d = loop do break [*[1,2],3]; end; assert_equal([1,2,3, 
[]], [a,b,c,d])
      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])
@@ -313,6 +341,7 @@
      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,d = loop do break *[*[1,2],3]; end; assert_equal([1,2,3, 
[]], [a,b,c,d])
    end
    def test_next
@@ -327,6 +356,7 @@
      r([]){next [*[]]}
      r([1]){next [*[1]]}
      r([1,2]){next [*[1,2]]}
+    r([1,2,3]){next [*[1,2],3]}
      r([]){next *[]}
      r([1]){next *[1]}
@@ -335,6 +365,7 @@
      r([]){next *[*[]]}
      r([1]){next *[*[1]]}
      r([1,2]){next *[*[1,2]]}
+    r([1,2,3]){next *[*[1,2],3]}
      undef r
      def r(val); *a = yield(); assert_equal(val, a); end
@@ -349,12 +380,14 @@
      r([]){next [*[]]}
      r([1]){next [*[1]]}
      r([1,2]){next [*[1,2]]}
+    r([1,2,3]){next [*[1,2],3]}
      undef r
      def r(val); *a = *yield(); assert_equal(val, a); end
      r([[]]){next *[[]]}
      r([1,2]){next *[1,2]}
      r([1,2]){next *[*[1,2]]}
+    r([1,2,3]){next *[*[1,2],3]}
      undef r
      def r(val); a,b,*c = yield(); assert_equal(val, [a,b,c]); end
@@ -371,11 +404,19 @@
      r([1,2,[]]){next [*[1,2]]}
      undef r
+    def r(val); a,b,c,d = yield(); assert_equal(val, [a,b,c,d]); end
+    r([1,2,3,[]]){next [*[1,2],3]}
+    undef r
+
      def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end
      r([[],nil,[]]){next *[[]]}
      r([1,2,[]]){next *[1,2]}
      r([1,2,[]]){next *[*[1,2]]}
      undef r
+
+    def r(val); a,b,c,*d = *yield(); assert_equal(val, [a,b,c,d]); end
+    r([1,2,3,[]]){next *[*[1,2],3]}
+    undef r
    end
    def test_assign2