1require 'test/unit'
2
3class TestAssignment < Test::Unit::TestCase
4  def test_assign
5    a=[]; a[0] ||= "bar";
6    assert_equal("bar", a[0])
7    h={}; h["foo"] ||= "bar";
8    assert_equal("bar", h["foo"])
9
10    aa = 5
11    aa ||= 25
12    assert_equal(5, aa)
13    bb ||= 25
14    assert_equal(25, bb)
15    cc &&=33
16    assert_nil(cc)
17    cc = 5
18    cc &&=44
19    assert_equal(44, cc)
20
21    a = nil; assert_nil(a)
22    a = 1; assert_equal(1, a)
23    a = []; assert_equal([], a)
24    a = [1]; assert_equal([1], a)
25    a = [nil]; assert_equal([nil], a)
26    a = [[]]; assert_equal([[]], a)
27    a = [1,2]; assert_equal([1,2], a)
28    a = [*[]]; assert_equal([], a)
29    a = [*[1]]; assert_equal([1], a)
30    a = [*[1,2]]; assert_equal([1,2], a)
31
32    a = *[]; assert_equal([], a)
33    a = *[1]; assert_equal([1], a)
34    a = *[nil]; assert_equal([nil], a)
35    a = *[[]]; assert_equal([[]], a)
36    a = *[1,2]; assert_equal([1,2], a)
37    a = *[*[]]; assert_equal([], a)
38    a = *[*[1]]; assert_equal([1], a)
39    a = *[*[1,2]]; assert_equal([1,2], a)
40
41    *a = nil; assert_equal([nil], a)
42    *a = 1; assert_equal([1], a)
43    *a = []; assert_equal([], a)
44    *a = [1]; assert_equal([1], a)
45    *a = [nil]; assert_equal([nil], a)
46    *a = [[]]; assert_equal([[]], a)
47    *a = [1,2]; assert_equal([1,2], a)
48    *a = [*[]]; assert_equal([], a)
49    *a = [*[1]]; assert_equal([1], a)
50    *a = [*[1,2]]; assert_equal([1,2], a)
51
52    *a = *[]; assert_equal([], a)
53    *a = *[1]; assert_equal([1], a)
54    *a = *[nil]; assert_equal([nil], a)
55    *a = *[[]]; assert_equal([[]], a)
56    *a = *[1,2]; assert_equal([1,2], a)
57    *a = *[*[]]; assert_equal([], a)
58    *a = *[*[1]]; assert_equal([1], a)
59    *a = *[*[1,2]]; assert_equal([1,2], a)
60
61    a,b,*c = nil; assert_equal([nil,nil,[]], [a,b,c])
62    a,b,*c = 1; assert_equal([1,nil,[]], [a,b,c])
63    a,b,*c = []; assert_equal([nil,nil,[]], [a,b,c])
64    a,b,*c = [1]; assert_equal([1,nil,[]], [a,b,c])
65    a,b,*c = [nil]; assert_equal([nil,nil,[]], [a,b,c])
66    a,b,*c = [[]]; assert_equal([[],nil,[]], [a,b,c])
67    a,b,*c = [1,2]; assert_equal([1,2,[]], [a,b,c])
68    a,b,*c = [*[]]; assert_equal([nil,nil,[]], [a,b,c])
69    a,b,*c = [*[1]]; assert_equal([1,nil,[]], [a,b,c])
70    a,b,*c = [*[1,2]]; assert_equal([1,2,[]], [a,b,c])
71
72    a,b,*c = *[]; assert_equal([nil,nil,[]], [a,b,c])
73    a,b,*c = *[1]; assert_equal([1,nil,[]], [a,b,c])
74    a,b,*c = *[nil]; assert_equal([nil,nil,[]], [a,b,c])
75    a,b,*c = *[[]]; assert_equal([[],nil,[]], [a,b,c])
76    a,b,*c = *[1,2]; assert_equal([1,2,[]], [a,b,c])
77    a,b,*c = *[*[]]; assert_equal([nil,nil,[]], [a,b,c])
78    a,b,*c = *[*[1]]; assert_equal([1,nil,[]], [a,b,c])
79    a,b,*c = *[*[1,2]]; assert_equal([1,2,[]], [a,b,c])
80
81    bug2050 = '[ruby-core:25629]'
82    a = Hash.new {[]}
83    b = [1, 2]
84    assert_equal([1, 2, 3], a[:x] += [*b, 3], bug2050)
85    assert_equal([1, 2, 3], a[:x], bug2050)
86    assert_equal([1, 2, 3, [1, 2, 3]], a[:x] <<= [*b, 3], bug2050)
87    assert_equal([1, 2, 3, [1, 2, 3]], a[:x], bug2050)
88  end
89
90  def test_yield
91    def f; yield(nil); end; f {|a| assert_nil(a)}; undef f
92    def f; yield(1); end; f {|a| assert_equal(1, a)}; undef f
93    def f; yield([]); end; f {|a| assert_equal([], a)}; undef f
94    def f; yield([1]); end; f {|a| assert_equal([1], a)}; undef f
95    def f; yield([nil]); end; f {|a| assert_equal([nil], a)}; undef f
96    def f; yield([[]]); end; f {|a| assert_equal([[]], a)}; undef f
97    def f; yield([*[]]); end; f {|a| assert_equal([], a)}; undef f
98    def f; yield([*[1]]); end; f {|a| assert_equal([1], a)}; undef f
99    def f; yield([*[1,2]]); end; f {|a| assert_equal([1,2], a)}; undef f
100
101    def f; yield(*[1]); end; f {|a| assert_equal(1, a)}; undef f
102    def f; yield(*[nil]); end; f {|a| assert_equal(nil, a)}; undef f
103    def f; yield(*[[]]); end; f {|a| assert_equal([], a)}; undef f
104    def f; yield(*[*[1]]); end; f {|a| assert_equal(1, a)}; undef f
105
106    def f; yield; end; f {|*a| assert_equal([], a)}; undef f
107    def f; yield(nil); end; f {|*a| assert_equal([nil], a)}; undef f
108    def f; yield(1); end; f {|*a| assert_equal([1], a)}; undef f
109    def f; yield([]); end; f {|*a| assert_equal([[]], a)}; undef f
110    def f; yield([1]); end; f {|*a| assert_equal([[1]], a)}; undef f
111    def f; yield([nil]); end; f {|*a| assert_equal([[nil]], a)}; undef f
112    def f; yield([[]]); end; f {|*a| assert_equal([[[]]], a)}; undef f
113    def f; yield([1,2]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
114    def f; yield([*[]]); end; f {|*a| assert_equal([[]], a)}; undef f
115    def f; yield([*[1]]); end; f {|*a| assert_equal([[1]], a)}; undef f
116    def f; yield([*[1,2]]); end; f {|*a| assert_equal([[1,2]], a)}; undef f
117
118    def f; yield(*[]); end; f {|*a| assert_equal([], a)}; undef f
119    def f; yield(*[1]); end; f {|*a| assert_equal([1], a)}; undef f
120    def f; yield(*[nil]); end; f {|*a| assert_equal([nil], a)}; undef f
121    def f; yield(*[[]]); end; f {|*a| assert_equal([[]], a)}; undef f
122    def f; yield(*[*[]]); end; f {|*a| assert_equal([], a)}; undef f
123    def f; yield(*[*[1]]); end; f {|*a| assert_equal([1], a)}; undef f
124    def f; yield(*[*[1,2]]); end; f {|*a| assert_equal([1,2], a)}; undef f
125
126    def f; yield; end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
127    def f; yield(nil); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
128    def f; yield(1); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
129    def f; yield([]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
130    def f; yield([1]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
131    def f; yield([nil]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
132    def f; yield([[]]); end; f {|a,b,*c| assert_equal([[],nil,[]], [a,b,c])}; undef f
133    def f; yield([*[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
134    def f; yield([*[1]]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
135    def f; yield([*[1,2]]); end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}; undef f
136
137    def f; yield(*[]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
138    def f; yield(*[1]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
139    def f; yield(*[nil]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
140    def f; yield(*[[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
141    def f; yield(*[*[]]); end; f {|a,b,*c| assert_equal([nil,nil,[]], [a,b,c])}; undef f
142    def f; yield(*[*[1]]); end; f {|a,b,*c| assert_equal([1,nil,[]], [a,b,c])}; undef f
143    def f; yield(*[*[1,2]]); end; f {|a,b,*c| assert_equal([1,2,[]], [a,b,c])}; undef f
144  end
145
146  def test_return
147    def r; return; end; a = r(); assert_nil(a); undef r
148    def r; return nil; end; a = r(); assert_nil(a); undef r
149    def r; return 1; end; a = r(); assert_equal(1, a); undef r
150    def r; return []; end; a = r(); assert_equal([], a); undef r
151    def r; return [1]; end; a = r(); assert_equal([1], a); undef r
152    def r; return [nil]; end; a = r(); assert_equal([nil], a); undef r
153    def r; return [[]]; end; a = r(); assert_equal([[]], a); undef r
154    def r; return [*[]]; end; a = r(); assert_equal([], a); undef r
155    def r; return [*[1]]; end; a = r(); assert_equal([1], a); undef r
156    def r; return [*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
157
158    def r; return *[]; end; a = r(); assert_equal([], a); undef r
159    def r; return *[1]; end; a = r(); assert_equal([1], a); undef r
160    def r; return *[nil]; end; a = r(); assert_equal([nil], a); undef r
161    def r; return *[[]]; end; a = r(); assert_equal([[]], a); undef r
162    def r; return *[*[]]; end; a = r(); assert_equal([], a); undef r
163    def r; return *[*[1]]; end; a = r(); assert_equal([1], a); undef r
164    def r; return *[*[1,2]]; end; a = r(); assert_equal([1,2], a); undef r
165
166    def r; return *[[]]; end; a = *r(); assert_equal([[]], a); undef r
167    def r; return *[*[1,2]]; end; a = *r(); assert_equal([1,2], a); undef r
168
169    def r; return; end; *a = r(); assert_equal([nil], a); undef r
170    def r; return nil; end; *a = r(); assert_equal([nil], a); undef r
171    def r; return 1; end; *a = r(); assert_equal([1], a); undef r
172    def r; return []; end; *a = r(); assert_equal([], a); undef r
173    def r; return [1]; end; *a = r(); assert_equal([1], a); undef r
174    def r; return [nil]; end; *a = r(); assert_equal([nil], a); undef r
175    def r; return [[]]; end; *a = r(); assert_equal([[]], a); undef r
176    def r; return [1,2]; end; *a = r(); assert_equal([1,2], a); undef r
177    def r; return [*[]]; end; *a = r(); assert_equal([], a); undef r
178    def r; return [*[1]]; end; *a = r(); assert_equal([1], a); undef r
179    def r; return [*[1,2]]; end; *a = r(); assert_equal([1,2], a); undef r
180
181    def r; return *[]; end; *a = r(); assert_equal([], a); undef r
182    def r; return *[1]; end; *a = r(); assert_equal([1], a); undef r
183    def r; return *[nil]; end; *a = r(); assert_equal([nil], a); undef r
184    def r; return *[[]]; end; *a = r(); assert_equal([[]], a); undef r
185    def r; return *[1,2]; end; *a = r(); assert_equal([1,2], a); undef r
186    def r; return *[*[]]; end; *a = r(); assert_equal([], a); undef r
187    def r; return *[*[1]]; end; *a = r(); assert_equal([1], a); undef r
188    def r; return *[*[1,2]]; end; *a = r(); assert_equal([1,2], a); undef r
189
190    def r; return *[[]]; end; *a = *r(); assert_equal([[]], a); undef r
191    def r; return *[1,2]; end; *a = *r(); assert_equal([1,2], a); undef r
192    def r; return *[*[1,2]]; end; *a = *r(); assert_equal([1,2], a); undef r
193
194    def r; return; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
195    def r; return nil; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
196    def r; return 1; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
197    def r; return []; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
198    def r; return [1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
199    def r; return [nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
200    def r; return [[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c]); undef r
201    def r; return [1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
202    def r; return [*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
203    def r; return [*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
204    def r; return [*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
205
206    def r; return *[]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
207    def r; return *[1]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
208    def r; return *[nil]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
209    def r; return *[[]]; end; a,b,*c = r(); assert_equal([[],nil,[]], [a,b,c]); undef r
210    def r; return *[1,2]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
211    def r; return *[*[]]; end; a,b,*c = r(); assert_equal([nil,nil,[]], [a,b,c]); undef r
212    def r; return *[*[1]]; end; a,b,*c = r(); assert_equal([1,nil,[]], [a,b,c]); undef r
213    def r; return *[*[1,2]]; end; a,b,*c = r(); assert_equal([1,2,[]], [a,b,c]); undef r
214
215    def r; return 1, *[]; end; a,b = r(); assert_equal([1,nil], [a,b]); undef r
216    def r; return 1,2,*[1]; end; a,b = r(); assert_equal([1,2], [a,b]); undef r
217    def r; return 1,2,3,*[1,2]; end; a,b = r(); assert_equal([1,2], [a,b]); undef r
218  end
219
220  def test_lambda
221    f = lambda {|r,| assert_equal([], r)}
222    f.call([], *[])
223
224    f = lambda {|r,*l| assert_equal([], r); assert_equal([1], l)}
225    f.call([], *[1])
226
227    f = lambda{|x| x}
228    assert_equal(42, f.call(42))
229    assert_equal([42], f.call([42]))
230    assert_equal([[42]], f.call([[42]]))
231    assert_equal([42,55], f.call([42,55]))
232
233    f = lambda{|x,| x}
234    assert_equal(42, f.call(42))
235    assert_equal([42], f.call([42]))
236    assert_equal([[42]], f.call([[42]]))
237    assert_equal([42,55], f.call([42,55]))
238
239    f = lambda{|*x| x}
240    assert_equal([42], f.call(42))
241    assert_equal([[42]], f.call([42]))
242    assert_equal([[[42]]], f.call([[42]]))
243    assert_equal([[42,55]], f.call([42,55]))
244    assert_equal([42,55], f.call(42,55))
245  end
246
247  def test_multi
248    a,=*[1]
249    assert_equal(1, a)
250    a,=*[[1]]
251    assert_equal([1], a)
252    a,=*[[[1]]]
253    assert_equal([[1]], a)
254
255    x, (y, z) = 1, 2, 3
256    assert_equal([1,2,nil], [x,y,z])
257    x, (y, z) = 1, [2,3]
258    assert_equal([1,2,3], [x,y,z])
259    x, (y, z) = 1, [2]
260    assert_equal([1,2,nil], [x,y,z])
261  end
262
263  def test_break
264    a = loop do break; end; assert_nil(a)
265    a = loop do break nil; end; assert_nil(a)
266    a = loop do break 1; end; assert_equal(1, a)
267    a = loop do break []; end; assert_equal([], a)
268    a = loop do break [1]; end; assert_equal([1], a)
269    a = loop do break [nil]; end; assert_equal([nil], a)
270    a = loop do break [[]]; end; assert_equal([[]], a)
271    a = loop do break [*[]]; end; assert_equal([], a)
272    a = loop do break [*[1]]; end; assert_equal([1], a)
273    a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
274
275    a = loop do break *[]; end; assert_equal([], a)
276    a = loop do break *[1]; end; assert_equal([1], a)
277    a = loop do break *[nil]; end; assert_equal([nil], a)
278    a = loop do break *[[]]; end; assert_equal([[]], a)
279    a = loop do break *[*[]]; end; assert_equal([], a)
280    a = loop do break *[*[1]]; end; assert_equal([1], a)
281    a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
282
283    *a = loop do break; end; assert_equal([nil], a)
284    *a = loop do break nil; end; assert_equal([nil], a)
285    *a = loop do break 1; end; assert_equal([1], a)
286    *a = loop do break []; end; assert_equal([], a)
287    *a = loop do break [1]; end; assert_equal([1], a)
288    *a = loop do break [nil]; end; assert_equal([nil], a)
289    *a = loop do break [[]]; end; assert_equal([[]], a)
290    *a = loop do break [1,2]; end; assert_equal([1,2], a)
291    *a = loop do break [*[]]; end; assert_equal([], a)
292    *a = loop do break [*[1]]; end; assert_equal([1], a)
293    *a = loop do break [*[1,2]]; end; assert_equal([1,2], a)
294
295    *a = loop do break *[]; end; assert_equal([], a)
296    *a = loop do break *[1]; end; assert_equal([1], a)
297    *a = loop do break *[nil]; end; assert_equal([nil], a)
298    *a = loop do break *[[]]; end; assert_equal([[]], a)
299    *a = loop do break *[1,2]; end; assert_equal([1,2], a)
300    *a = loop do break *[*[]]; end; assert_equal([], a)
301    *a = loop do break *[*[1]]; end; assert_equal([1], a)
302    *a = loop do break *[*[1,2]]; end; assert_equal([1,2], a)
303
304    *a = *loop do break *[[]]; end; assert_equal([[]], a)
305    *a = *loop do break *[1,2]; end; assert_equal([1,2], a)
306    *a = *loop do break *[*[1,2]]; end; assert_equal([1,2], a)
307
308    a,b,*c = loop do break; end; assert_equal([nil,nil,[]], [a,b,c])
309    a,b,*c = loop do break nil; end; assert_equal([nil,nil,[]], [a,b,c])
310    a,b,*c = loop do break 1; end; assert_equal([1,nil,[]], [a,b,c])
311    a,b,*c = loop do break []; end; assert_equal([nil,nil,[]], [a,b,c])
312    a,b,*c = loop do break [1]; end; assert_equal([1,nil,[]], [a,b,c])
313    a,b,*c = loop do break [nil]; end; assert_equal([nil,nil,[]], [a,b,c])
314    a,b,*c = loop do break [[]]; end; assert_equal([[],nil,[]], [a,b,c])
315    a,b,*c = loop do break [1,2]; end; assert_equal([1,2,[]], [a,b,c])
316    a,b,*c = loop do break [*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
317    a,b,*c = loop do break [*[1]]; end; assert_equal([1,nil,[]], [a,b,c])
318    a,b,*c = loop do break [*[1,2]]; end; assert_equal([1,2,[]], [a,b,c])
319
320    a,b,*c = loop do break *[]; end; assert_equal([nil,nil,[]], [a,b,c])
321    a,b,*c = loop do break *[1]; end; assert_equal([1,nil,[]], [a,b,c])
322    a,b,*c = loop do break *[nil]; end; assert_equal([nil,nil,[]], [a,b,c])
323    a,b,*c = loop do break *[[]]; end; assert_equal([[],nil,[]], [a,b,c])
324    a,b,*c = loop do break *[1,2]; end; assert_equal([1,2,[]], [a,b,c])
325    a,b,*c = loop do break *[*[]]; end; assert_equal([nil,nil,[]], [a,b,c])
326    a,b,*c = loop do break *[*[1]]; end; assert_equal([1,nil,[]], [a,b,c])
327    a,b,*c = loop do break *[*[1,2]]; end; assert_equal([1,2,[]], [a,b,c])
328  end
329
330  def test_next
331    def r(val); a = yield(); assert_equal(val, a); end
332    r(nil){next}
333    r(nil){next nil}
334    r(1){next 1}
335    r([]){next []}
336    r([1]){next [1]}
337    r([nil]){next [nil]}
338    r([[]]){next [[]]}
339    r([]){next [*[]]}
340    r([1]){next [*[1]]}
341    r([1,2]){next [*[1,2]]}
342
343    r([]){next *[]}
344    r([1]){next *[1]}
345    r([nil]){next *[nil]}
346    r([[]]){next *[[]]}
347    r([]){next *[*[]]}
348    r([1]){next *[*[1]]}
349    r([1,2]){next *[*[1,2]]}
350    undef r
351
352    def r(val); *a = yield(); assert_equal(val, a); end
353    r([nil]){next}
354    r([nil]){next nil}
355    r([1]){next 1}
356    r([]){next []}
357    r([1]){next [1]}
358    r([nil]){next [nil]}
359    r([[]]){next [[]]}
360    r([1,2]){next [1,2]}
361    r([]){next [*[]]}
362    r([1]){next [*[1]]}
363    r([1,2]){next [*[1,2]]}
364    undef r
365
366    def r(val); *a = *yield(); assert_equal(val, a); end
367    r([[]]){next *[[]]}
368    r([1,2]){next *[1,2]}
369    r([1,2]){next *[*[1,2]]}
370    undef r
371
372    def r(val); a,b,*c = yield(); assert_equal(val, [a,b,c]); end
373    r([nil,nil,[]]){next}
374    r([nil,nil,[]]){next nil}
375    r([1,nil,[]]){next 1}
376    r([nil,nil,[]]){next []}
377    r([1,nil,[]]){next [1]}
378    r([nil,nil,[]]){next [nil]}
379    r([[],nil,[]]){next [[]]}
380    r([1,2,[]]){next [1,2]}
381    r([nil,nil,[]]){next [*[]]}
382    r([1,nil,[]]){next [*[1]]}
383    r([1,2,[]]){next [*[1,2]]}
384    undef r
385
386    def r(val); a,b,*c = *yield(); assert_equal(val, [a,b,c]); end
387    r([[],nil,[]]){next *[[]]}
388    r([1,2,[]]){next *[1,2]}
389    r([1,2,[]]){next *[*[1,2]]}
390    undef r
391  end
392
393  def test_massign
394    a = nil
395    assert(defined?(a))
396    assert_nil(a)
397
398    # multiple asignment
399    a, b = 1, 2
400    assert_equal 1, a
401    assert_equal 2, b
402
403    a, b, c = 1, 2, 3
404    assert_equal 1, a
405    assert_equal 2, b
406    assert_equal 3, c
407
408    a = 1
409    b = 2
410    a, b = b, a
411    assert_equal 2, a
412    assert_equal 1, b
413
414    a, = 1, 2
415    assert_equal 1, a
416
417    a, = 1, 2, 3
418    assert_equal 1, a
419
420    a, * = 1, 2, 3
421    assert_equal 1, a
422
423    a, *b = 1, 2, 3
424    assert_equal 1, a
425    assert_equal [2, 3], b
426
427    # not supported yet
428    #a, *b, c = 1, 2, 3, 4
429    #assert_equal 1, a
430    #assert_equal [2,3], b
431    #assert_equal 4, c
432
433    a = 1, 2
434    assert_equal [1, 2], a
435
436    a = [1, 2], [3, 4]
437    assert_equal [[1,2], [3,4]], a
438
439    a, (b, c), d = 1, [2, 3], 4
440    assert_equal 1, a
441    assert_equal 2, b
442    assert_equal 3, c
443    assert_equal 4, d
444
445    *a = 1, 2, 3
446    assert_equal([1, 2, 3], a)
447
448    *a = 4
449    assert_equal([4], a)
450
451    *a = nil
452    assert_equal([nil], a)
453
454    a, b = 1
455    assert_equal 1, a
456    assert_nil b
457
458    a, b = [1, 2]
459    assert_equal 1, a
460    assert_equal 2, b
461  end
462
463  def test_nested_massign
464    (a, b), c = [[1, 2], 3]; assert_equal [1,2,3], [a,b,c]
465    a, (b, c) = [[1, 2], 3]; assert_equal [[1,2], 3, nil], [a,b,c]
466    a, (b, c) = [1, [2, 3]]; assert_equal [1,2,3], [a,b,c]
467    (a, b), *c = [[1, 2], 3]; assert_equal [1,2,[3]], [a,b,c]
468    (a,b),c,(d,e) = [[1,2],3,[4,5]]; assert_equal [1,2,3,4,5],[a,b,c,d,e]
469    (a,*b),c,(d,e,*) = [[1,2],3,[4,5]]; assert_equal [1,[2],3,4,5],[a,b,c,d,e]
470    (a,b),c,(d,*e) = [[1,2,3],4,[5,6,7,8]]; assert_equal [1,2,4,5,[6,7,8]],[a,b,c,d,e]
471    (a,(b1,b2)),c,(d,e) = [[1,2],3,[4,5]]; assert_equal [1,2,nil,3,4,5],[a,b1,b2,c,d,e]
472    (a,(b1,b2)),c,(d,e) = [[1,[21,22]],3,[4,5]]; assert_equal [1,21,22,3,4,5],[a,b1,b2,c,d,e]
473  end
474
475  class MyObj
476    def to_ary
477      [[1,2],[3,4]]
478    end
479  end
480
481  def test_to_ary_splat
482    a, b = MyObj.new
483    assert_equal [[1,2],[3,4]], [a,b]
484  end
485
486  A = 1
487  B = 2
488  X, Y = A, B
489  class Base
490    A = 3
491    B = 4
492  end
493
494  def test_const_massign
495    assert_equal [1,2], [X,Y]
496    a, b = Base::A, Base::B
497    assert_equal [3,4], [a,b]
498  end
499end
500
501require_relative 'sentence'
502class TestAssignmentGen < Test::Unit::TestCase
503  Syntax = {
504    :exp => [["0"],
505             ["nil"],
506             ["false"],
507             ["[]"],
508             ["[",:exps,"]"]],
509    :exps => [[:exp],
510              [:exp,",",:exps]],
511    :arg => [[:exp]],
512    :mrhs => [[:args,",",:arg],
513              [:args,",","*",:arg],
514              ["*",:arg]],
515    :args => [[:arg],
516              ["*",:arg],
517              [:args,",",:arg],
518              [:args,",","*",:arg]],
519    :mlhs => [[:mlhs_basic],
520              ["(",:mlhs_inner,")"]],
521    :mlhs_inner => [[:mlhs_basic],
522              ["(",:mlhs_inner,")"]],
523    :mlhs_basic => [[:mlhs_head],
524                    [:mlhs_head,:mlhs_item],
525                    [:mlhs_head,"*",:mlhs_node],
526                    [:mlhs_head,"*",:mlhs_node,",",:mlhs_post],
527                    [:mlhs_head,"*"],
528                    [:mlhs_head,"*",",",           :mlhs_post],
529                    [           "*",:mlhs_node],
530                    [           "*",:mlhs_node,",",:mlhs_post],
531                    [           "*"],
532                    [           "*",",",           :mlhs_post]],
533    :mlhs_head => [[:mlhs_item,","],
534                   [:mlhs_head,:mlhs_item,","]],
535    :mlhs_post => [[:mlhs_item],
536                   [:mlhs_post,",",:mlhs_item]],
537    :mlhs_item => [[:mlhs_node],
538                   ["(",:mlhs_inner,")"]],
539    :mlhs_node => [["var"]],
540    :xassign => [["var"," = ",:exp],
541                 ["var"," = ",:mrhs],
542                 [:mlhs," = ",:exp],
543                 [:mlhs," = ",:mrhs]],
544  }
545
546  def rename_var(obj)
547    vars = []
548    r = obj.subst('var') {
549      var = "v#{vars.length}"
550      vars << var
551      var
552    }
553    return r, vars
554  end
555
556  def expand_except_paren(obj)
557    return obj if obj.respond_to? :to_str
558    obj.expand {|s|
559      !(s[0] == '(' && s[-1] == ')') &&
560      !(s[0] == '[' && s[-1] == ']')
561    }
562  end
563
564  def extract_single_element(ary)
565    raise "not a single element array: #{ary.inspect}" if ary.length != 1
566    ary[0]
567  end
568
569  def emu_assign_ary(lhs, rv, h)
570    rv = rv.respond_to?(:to_ary) ? rv : [rv]
571    rv = rv.dup
572    a = [[]]
573    lhs.each {|e|
574      if e == ','
575        a << []
576      else
577        a.last << e
578      end
579    }
580    a.pop if a.last == []
581    pre = []
582    star = post = nil
583    a.each {|e|
584      if post
585        post << e
586      elsif e[0] == '*'
587        star = e
588        post = []
589      else
590        pre << e
591      end
592    }
593    pre.map! {|e| extract_single_element(e) }
594    if star
595      if star == ['*']
596        star = nil
597      else
598        star = extract_single_element(star[1..-1])
599      end
600    end
601    post.map! {|e| extract_single_element(e) } if post
602
603    until pre.empty?
604      emu_assign_single(pre.shift, rv.shift, h)
605    end
606
607    if post
608      if rv.length < post.length
609        until post.empty?
610          emu_assign_single(post.shift, rv.shift, h)
611        end
612      else
613        until post.empty?
614          emu_assign_single(post.pop, rv.pop, h)
615        end
616      end
617    end
618
619    if star
620      emu_assign_single(star, rv, h)
621    end
622  end
623
624  def emu_assign_single(lhs, rv, h={})
625    if lhs.respond_to? :to_str
626      if /\A[a-z0-9]+\z/ =~ lhs
627        h[lhs] = rv
628      else
629        raise "unexpected lhs string: #{lhs.inspect}"
630      end
631    elsif Sentence === lhs
632      if lhs[0] == '(' && lhs[-1] == ')'
633        emu_assign_ary(lhs[1...-1], rv, h)
634      elsif lhs.length == 1 && String === lhs[0] && /\A[a-z0-9]+\z/ =~ lhs[0]
635        h[lhs[0]] = rv
636      else
637        raise "unexpected lhs sentence: #{lhs.inspect}"
638      end
639    else
640      raise "unexpected lhs: #{lhs.inspect}"
641    end
642    h
643  end
644
645  def emu_assign(assign)
646    lhs = expand_except_paren(assign[0])
647    rhs = expand_except_paren(assign[2])
648    lopen = Sentence === lhs && lhs[-1] != ')' && lhs.any? {|e| e == '*' || e == ',' }
649    ropen = Sentence === rhs && rhs[-1] != ']' && rhs.any? {|e| e == '*' || e == ',' }
650    lhs = Sentence.new(['(']+lhs.to_a+[')']) if lopen
651    begin
652      rv = eval((ropen ? ["[",assign[2],"]"] : assign[2]).join(''))
653    rescue Exception
654      rv = $!.message
655    end
656    emu_assign_single(lhs, rv)
657  end
658
659  def do_assign(assign, vars)
660    assign = assign.to_s
661    code1 = "#{assign}; [#{vars.join(",")}]"
662    assign.gsub!(/\bv\d+\b/, "o.a")
663    code2 = "o=[];class << o; self end.send(:define_method,:a=){|v|self << v};#{assign};o"
664    begin
665      vals1 = eval(code1)
666    rescue Exception
667      return {:ex=>$!.message}
668    end
669    begin
670      vals2 = eval(code2)
671    rescue Exception
672      return {:ex=>$!.message}
673    end
674    assert_equal(vals1, vals2, code1)
675    vals = vals1
676    h = {}
677    [vars, vals].transpose.each {|k,v| h[k] = v }
678    h
679  end
680
681  def check(assign)
682    assign, vars = rename_var(assign)
683    sent = assign.to_s
684    bruby = do_assign(assign, vars).to_a.sort
685    bemu = emu_assign(assign).to_a.sort
686    assert_equal(bemu, bruby, sent)
687  end
688
689  def test_assignment
690    syntax = Sentence.expand_syntax(Syntax)
691    Sentence.each(syntax, :xassign, 4) {|assign|
692      check(assign)
693    }
694  end
695end
696