1# regular argument
2assert_equal '1',       'def m() 1 end; m()'
3assert_equal '1',       'def m(a) a end; m(1)'
4assert_equal '[1, 2]',  'def m(a,b) [a, b] end; m(1,2)'
5assert_equal '[1, 2, 3]', 'def m(a,b,c) [a, b, c] end; m(1,2,3)'
6assert_equal 'wrong number of arguments (1 for 0)', %q{
7  def m; end
8  begin
9    m(1)
10  rescue => e
11    e.message
12  end
13}
14
15assert_equal 'wrong number of arguments (0 for 1)', %q{
16  def m a; end
17  begin
18    m
19  rescue => e
20    e.message
21  end
22}
23
24# default argument
25assert_equal '1',       'def m(x=1) x end; m()'
26assert_equal '1',       'def m(x=7) x end; m(1)'
27assert_equal '1',       'def m(a,x=1) x end; m(7)'
28assert_equal '1',       'def m(a,x=7) x end; m(7,1)'
29assert_equal '1',       'def m(a,b,x=1) x end; m(7,7)'
30assert_equal '1',       'def m(a,b,x=7) x end; m(7,7,1)'
31assert_equal '1',       'def m(a,x=1,y=1) x end; m(7)'
32assert_equal '1',       'def m(a,x=1,y=1) y end; m(7)'
33assert_equal '1',       'def m(a,x=7,y=1) x end; m(7,1)'
34assert_equal '1',       'def m(a,x=7,y=1) y end; m(7,1)'
35assert_equal '1',       'def m(a,x=7,y=7) x end; m(7,1,1)'
36assert_equal '1',       'def m(a,x=7,y=7) y end; m(7,1,1)'
37
38# rest argument
39assert_equal '[]',      'def m(*a) a end; m().inspect'
40assert_equal '[1]',     'def m(*a) a end; m(1).inspect'
41assert_equal '[1, 2]',  'def m(*a) a end; m(1,2).inspect'
42assert_equal '[]',      'def m(x,*a) a end; m(7).inspect'
43assert_equal '[1]',     'def m(x,*a) a end; m(7,1).inspect'
44assert_equal '[1, 2]',  'def m(x,*a) a end; m(7,1,2).inspect'
45assert_equal '[]',      'def m(x,y,*a) a end; m(7,7).inspect'
46assert_equal '[1]',     'def m(x,y,*a) a end; m(7,7,1).inspect'
47assert_equal '[1, 2]',  'def m(x,y,*a) a end; m(7,7,1,2).inspect'
48assert_equal '[]',      'def m(x,y=7,*a) a end; m(7).inspect'
49assert_equal '[]',      'def m(x,y,z=7,*a) a end; m(7,7).inspect'
50assert_equal '[]',      'def m(x,y,z=7,*a) a end; m(7,7,7).inspect'
51assert_equal '[]',      'def m(x,y,z=7,zz=7,*a) a end; m(7,7,7).inspect'
52assert_equal '[]',      'def m(x,y,z=7,zz=7,*a) a end; m(7,7,7,7).inspect'
53assert_equal '1',       'def m(x,y,z=7,zz=1,*a) zz end; m(7,7,7).inspect'
54assert_equal '1',       'def m(x,y,z=7,zz=1,*a) zz end; m(7,7,7).inspect'
55assert_equal '1',       'def m(x,y,z=7,zz=7,*a) zz end; m(7,7,7,1).inspect'
56
57# block argument
58assert_equal 'Proc',    'def m(&block) block end; m{}.class'
59assert_equal 'nil',     'def m(&block) block end; m().inspect'
60assert_equal 'Proc',    'def m(a,&block) block end; m(7){}.class'
61assert_equal 'nil',     'def m(a,&block) block end; m(7).inspect'
62assert_equal '1',       'def m(a,&block) a end; m(1){}'
63assert_equal 'Proc',    'def m(a,b=nil,&block) block end; m(7){}.class'
64assert_equal 'nil',     'def m(a,b=nil,&block) block end; m(7).inspect'
65assert_equal 'Proc',    'def m(a,b=nil,&block) block end; m(7,7){}.class'
66assert_equal '1',       'def m(a,b=nil,&block) b end; m(7,1){}'
67assert_equal 'Proc',    'def m(a,b=nil,*c,&block) block end; m(7){}.class'
68assert_equal 'nil',     'def m(a,b=nil,*c,&block) block end; m(7).inspect'
69assert_equal '1',       'def m(a,b=nil,*c,&block) a end; m(1).inspect'
70assert_equal '1',       'def m(a,b=1,*c,&block) b end; m(7).inspect'
71assert_equal '1',       'def m(a,b=7,*c,&block) b end; m(7,1).inspect'
72assert_equal '[1]',     'def m(a,b=7,*c,&block) c end; m(7,7,1).inspect'
73
74# splat
75assert_equal '1',       'def m(a) a end; m(*[1])'
76assert_equal '1',       'def m(x,a) a end; m(7,*[1])'
77assert_equal '1',       'def m(x,y,a) a end; m(7,7,*[1])'
78assert_equal '1',       'def m(a,b) a end; m(*[1,7])'
79assert_equal '1',       'def m(a,b) b end; m(*[7,1])'
80assert_equal '1',       'def m(x,a,b) b end; m(7,*[7,1])'
81assert_equal '1',       'def m(x,y,a,b) b end; m(7,7,*[7,1])'
82assert_equal '1',       'def m(a,b,c) a end; m(*[1,7,7])'
83assert_equal '1',       'def m(a,b,c) b end; m(*[7,1,7])'
84assert_equal '1',       'def m(a,b,c) c end; m(*[7,7,1])'
85assert_equal '1',       'def m(x,a,b,c) a end; m(7,*[1,7,7])'
86assert_equal '1',       'def m(x,y,a,b,c) a end; m(7,7,*[1,7,7])'
87
88# hash argument
89assert_equal '1',       'def m(h) h end; m(7=>1)[7]'
90assert_equal '1',       'def m(h) h end; m(7=>1).size'
91assert_equal '1',       'def m(h) h end; m(7=>1, 8=>7)[7]'
92assert_equal '2',       'def m(h) h end; m(7=>1, 8=>7).size'
93assert_equal '1',       'def m(h) h end; m(7=>1, 8=>7, 9=>7)[7]'
94assert_equal '3',       'def m(h) h end; m(7=>1, 8=>7, 9=>7).size'
95assert_equal '1',       'def m(x,h) h end; m(7, 7=>1)[7]'
96assert_equal '1',       'def m(x,h) h end; m(7, 7=>1, 8=>7)[7]'
97assert_equal '1',       'def m(x,h) h end; m(7, 7=>1, 8=>7, 9=>7)[7]'
98assert_equal '1',       'def m(x,y,h) h end; m(7,7, 7=>1)[7]'
99assert_equal '1',       'def m(x,y,h) h end; m(7,7, 7=>1, 8=>7)[7]'
100assert_equal '1',       'def m(x,y,h) h end; m(7,7, 7=>1, 8=>7, 9=>7)[7]'
101
102# block argument
103assert_equal '1',       %q(def m(&block) mm(&block) end
104                           def mm() yield 1 end
105                           m {|a| a })
106assert_equal '1',       %q(def m(x,&block) mm(x,&block) end
107                           def mm(x) yield 1 end
108                           m(7) {|a| a })
109assert_equal '1',       %q(def m(x,y,&block) mm(x,y,&block) end
110                           def mm(x,y) yield 1 end
111                           m(7,7) {|a| a })
112
113# recursive call
114assert_equal '1',       %q(def m(n) n == 0 ? 1 : m(n-1) end; m(5))
115
116# instance method
117assert_equal '1',       %q(class C; def m() 1 end end;  C.new.m)
118assert_equal '1',       %q(class C; def m(a) a end end;  C.new.m(1))
119assert_equal '1',       %q(class C; def m(a = 1) a end end;  C.new.m)
120assert_equal '[1]',     %q(class C; def m(*a) a end end;  C.new.m(1).inspect)
121assert_equal '1',       %q( class C
122                              def m() mm() end
123                              def mm() 1 end
124                            end
125                            C.new.m )
126
127# singleton method (const)
128assert_equal '1',       %q(class C; def C.m() 1 end end;  C.m)
129assert_equal '1',       %q(class C; def C.m(a) a end end;  C.m(1))
130assert_equal '1',       %q(class C; def C.m(a = 1) a end end;  C.m)
131assert_equal '[1]',     %q(class C; def C.m(*a) a end end;  C.m(1).inspect)
132assert_equal '1',       %q(class C; end; def C.m() 1 end;  C.m)
133assert_equal '1',       %q(class C; end; def C.m(a) a end;  C.m(1))
134assert_equal '1',       %q(class C; end; def C.m(a = 1) a end;  C.m)
135assert_equal '[1]',     %q(class C; end; def C.m(*a) a end;  C.m(1).inspect)
136assert_equal '1',       %q(class C; def m() 7 end end; def C.m() 1 end;  C.m)
137assert_equal '1',       %q( class C
138                              def C.m() mm() end
139                              def C.mm() 1 end
140                            end
141                            C.m )
142
143# singleton method (lvar)
144assert_equal '1',       %q(obj = Object.new; def obj.m() 1 end;  obj.m)
145assert_equal '1',       %q(obj = Object.new; def obj.m(a) a end;  obj.m(1))
146assert_equal '1',       %q(obj = Object.new; def obj.m(a=1) a end;  obj.m)
147assert_equal '[1]',     %q(obj = Object.new; def obj.m(*a) a end;  obj.m(1))
148assert_equal '1',       %q(class C; def m() 7 end; end
149                           obj = C.new
150                           def obj.m() 1 end
151                           obj.m)
152
153# inheritance
154assert_equal '1',       %q(class A; def m(a) a end end
155                           class B < A; end
156                           B.new.m(1))
157assert_equal '1',       %q(class A; end
158                           class B < A; def m(a) a end end
159                           B.new.m(1))
160assert_equal '1',       %q(class A; def m(a) a end end
161                           class B < A; end
162                           class C < B; end
163                           C.new.m(1))
164
165# include
166assert_equal '1',       %q(class A; def m(a) a end end
167                           module M; end
168                           class B < A; include M; end
169                           B.new.m(1))
170assert_equal '1',       %q(class A; end
171                           module M; def m(a) a end end
172                           class B < A; include M; end
173                           B.new.m(1))
174
175# alias
176assert_equal '1',       %q( def a() 1 end
177                            alias m a
178                            m() )
179assert_equal '1',       %q( class C
180                              def a() 1 end
181                              alias m a
182                            end
183                            C.new.m )
184assert_equal '1',       %q( class C
185                              def a() 1 end
186                              alias :m a
187                            end
188                            C.new.m )
189assert_equal '1',       %q( class C
190                              def a() 1 end
191                              alias m :a
192                            end
193                            C.new.m )
194assert_equal '1',       %q( class C
195                              def a() 1 end
196                              alias :m :a
197                            end
198                            C.new.m )
199assert_equal '1',       %q( class C
200                              def a() 1 end
201                              alias m a
202                              undef a
203                            end
204                            C.new.m )
205
206# undef
207assert_equal '1',       %q( class C
208                              def m() end
209                              undef m
210                            end
211                            begin C.new.m; rescue NoMethodError; 1 end )
212assert_equal '1',       %q( class A
213                              def m() end
214                            end
215                            class C < A
216                              def m() end
217                              undef m
218                            end
219                            begin C.new.m; rescue NoMethodError; 1 end )
220assert_equal '1',       %q( class A; def a() end end   # [yarv-dev:999]
221                            class B < A
222                              def b() end
223                              undef a, b
224                            end
225                            begin B.new.a; rescue NoMethodError; 1 end )
226assert_equal '1',       %q( class A; def a() end end   # [yarv-dev:999]
227                            class B < A
228                              def b() end
229                              undef a, b
230                            end
231                            begin B.new.b; rescue NoMethodError; 1 end )
232
233assert_equal '3',  %q{
234  def m1
235    1
236  end
237  alias m2 m1
238  alias :"#{'m3'}" m1
239  m1 + m2 + m3
240}, '[ruby-dev:32308]'
241assert_equal '1', %q{
242  def foobar
243  end
244  undef :"foo#{:bar}"
245  1
246}, '[ruby-dev:32308]'
247assert_equal '1', %q{
248  def foobar
249    1
250  end
251  alias :"bar#{:baz}" :"foo#{:bar}"
252  barbaz
253}, '[ruby-dev:32308]'
254
255# private
256assert_equal '1',       %q( class C
257                              def m() mm() end
258                              def mm() 1 end
259                              private :mm
260                            end
261                            C.new.m )
262assert_equal '1',       %q( class C
263                              def m() 7 end
264                              private :m
265                            end
266                            begin C.m; rescue NoMethodError; 1 end )
267assert_equal '1',       %q( class C
268                              def C.m() mm() end
269                              def C.mm() 1 end
270                              private_class_method :mm
271                            end
272                            C.m )
273assert_equal '1',       %q( class C
274                              def C.m() 7 end
275                              private_class_method :m
276                            end
277                            begin C.m; rescue NoMethodError; 1 end )
278assert_equal '1',       %q( class C; def m() 1 end end
279                            C.new.m   # cache
280                            class C
281                              alias mm m; private :mm
282                            end
283                            C.new.m
284                            begin C.new.mm; 7; rescue NoMethodError; 1 end )
285
286# nested method
287assert_equal '1',       %q( class C
288                              def m
289                                def mm() 1 end
290                              end
291                            end
292                            C.new.m
293                            C.new.mm )
294assert_equal '1',       %q( class C
295                              def m
296                                def mm() 1 end
297                              end
298                            end
299                            instance_eval "C.new.m; C.new.mm" )
300
301# method_missing
302assert_equal ':m',      %q( class C
303                              def method_missing(mid, *args) mid end
304                            end
305                            C.new.m.inspect )
306assert_equal ':mm',     %q( class C
307                              def method_missing(mid, *args) mid end
308                            end
309                            C.new.mm.inspect )
310assert_equal '[1, 2]',  %q( class C
311                              def method_missing(mid, *args) args end
312                            end
313                            C.new.m(1,2).inspect )
314assert_equal '1',       %q( class C
315                              def method_missing(mid, *args) yield 1 end
316                            end
317                            C.new.m {|a| a })
318assert_equal 'nil',     %q( class C
319                              def method_missing(mid, *args, &block) block end
320                            end
321                            C.new.m.inspect )
322
323# send
324assert_equal '1',       %q( class C; def m() 1 end end;
325                            C.new.__send__(:m) )
326assert_equal '1',       %q( class C; def m() 1 end end;
327                            C.new.send(:m) )
328assert_equal '1',       %q( class C; def m(a) a end end;
329                            C.new.send(:m,1) )
330assert_equal '1',       %q( class C; def m(a,b) a end end;
331                            C.new.send(:m,1,7) )
332assert_equal '1',       %q( class C; def m(x,a=1) a end end;
333                            C.new.send(:m,7) )
334assert_equal '1',       %q( class C; def m(x,a=7) a end end;
335                            C.new.send(:m,7,1) )
336assert_equal '[1, 2]',  %q( class C; def m(*a) a end end;
337                            C.new.send(:m,1,2).inspect )
338assert_equal '1',       %q( class C; def m() 7 end; private :m end
339                            begin C.new.public_send(:m); rescue NoMethodError; 1 end )
340assert_equal '1',       %q( class C; def m() 1 end; private :m end
341                            C.new.send(:m) )
342
343# with block
344assert_equal '[[:ok1, :foo], [:ok2, :foo, :bar]]',
345%q{
346  class C
347    def [](a)
348      $ary << [yield, a]
349    end
350    def []=(a, b)
351      $ary << [yield, a, b]
352    end
353  end
354
355  $ary = []
356  C.new[:foo, &lambda{:ok1}]
357  C.new[:foo, &lambda{:ok2}] = :bar
358  $ary
359}
360
361# with
362assert_equal '[:ok1, [:ok2, 11]]', %q{
363  class C
364    def []
365      $ary << :ok1
366      10
367    end
368    def []=(a)
369      $ary << [:ok2, a]
370    end
371  end
372  $ary = []
373  C.new[]+=1
374  $ary
375}
376
377# splat and block arguments
378assert_equal %q{[[[:x, :y, :z], NilClass], [[1, :x, :y, :z], NilClass], [[1, 2, :x, :y, :z], NilClass], [[:obj], NilClass], [[1, :obj], NilClass], [[1, 2, :obj], NilClass], [[], Proc], [[1], Proc], [[1, 2], Proc], [[], Proc], [[1], Proc], [[1, 2], Proc], [[:x, :y, :z], Proc], [[1, :x, :y, :z], Proc], [[1, 2, :x, :y, :z], Proc]]}, %q{
379def m(*args, &b)
380  $result << [args, b.class]
381end
382$result = []
383ary = [:x, :y, :z]
384obj = :obj
385b = Proc.new{}
386
387m(*ary)
388m(1,*ary)
389m(1,2,*ary)
390m(*obj)
391m(1,*obj)
392m(1,2,*obj)
393m(){}
394m(1){}
395m(1,2){}
396m(&b)
397m(1,&b)
398m(1,2,&b)
399m(*ary,&b)
400m(1,*ary,&b)
401m(1,2,*ary,&b)
402$result
403}
404
405# aset and splat
406assert_equal '4', %q{class Foo;def []=(a,b,c,d);end;end;Foo.new[1,*a=[2,3]]=4}
407assert_equal '4', %q{class Foo;def []=(a,b,c,d);end;end;def m(&blk)Foo.new[1,*a=[2,3],&blk]=4;end;m{}}
408
409# post test
410assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, NilClass, nil, nil]}, %q{
411def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
412  x, y = :x, :y if $foo
413  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
414end
415; m(1, 2, 3, 4)}
416
417assert_equal %q{[1, 2, 3, :o2, [], 4, 5, NilClass, nil, nil]}, %q{
418def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
419  x, y = :x, :y if $foo
420  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
421end
422; m(1, 2, 3, 4, 5)}
423
424assert_equal %q{[1, 2, 3, 4, [], 5, 6, NilClass, nil, nil]}, %q{
425def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
426  x, y = :x, :y if $foo
427  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
428end
429; m(1, 2, 3, 4, 5, 6)}
430
431assert_equal %q{[1, 2, 3, 4, [5], 6, 7, NilClass, nil, nil]}, %q{
432def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
433  x, y = :x, :y if $foo
434  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
435end
436; m(1, 2, 3, 4, 5, 6, 7)}
437
438assert_equal %q{[1, 2, 3, 4, [5, 6], 7, 8, NilClass, nil, nil]}, %q{
439def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
440  x, y = :x, :y if $foo
441  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
442end
443; m(1, 2, 3, 4, 5, 6, 7, 8)}
444
445assert_equal %q{[1, 2, 3, 4, [5, 6, 7], 8, 9, NilClass, nil, nil]}, %q{
446def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
447  x, y = :x, :y if $foo
448  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
449end
450; m(1, 2, 3, 4, 5, 6, 7, 8, 9)}
451
452assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8], 9, 10, NilClass, nil, nil]}, %q{
453def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
454  x, y = :x, :y if $foo
455  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
456end
457; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)}
458
459assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8, 9], 10, 11, NilClass, nil, nil]}, %q{
460def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
461  x, y = :x, :y if $foo
462  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
463end
464; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)}
465
466assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, Proc, nil, nil]}, %q{
467def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
468  x, y = :x, :y if $foo
469  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
470end
471; m(1, 2, 3, 4){}}
472
473assert_equal %q{[1, 2, 3, :o2, [], 4, 5, Proc, nil, nil]}, %q{
474def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
475  x, y = :x, :y if $foo
476  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
477end
478; m(1, 2, 3, 4, 5){}}
479
480assert_equal %q{[1, 2, 3, 4, [], 5, 6, Proc, nil, nil]}, %q{
481def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
482  x, y = :x, :y if $foo
483  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
484end
485; m(1, 2, 3, 4, 5, 6){}}
486
487assert_equal %q{[1, 2, 3, 4, [5], 6, 7, Proc, nil, nil]}, %q{
488def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
489  x, y = :x, :y if $foo
490  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
491end
492; m(1, 2, 3, 4, 5, 6, 7){}}
493
494assert_equal %q{[1, 2, 3, 4, [5, 6], 7, 8, Proc, nil, nil]}, %q{
495def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
496  x, y = :x, :y if $foo
497  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
498end
499; m(1, 2, 3, 4, 5, 6, 7, 8){}}
500
501assert_equal %q{[1, 2, 3, 4, [5, 6, 7], 8, 9, Proc, nil, nil]}, %q{
502def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
503  x, y = :x, :y if $foo
504  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
505end
506; m(1, 2, 3, 4, 5, 6, 7, 8, 9){}}
507
508assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8], 9, 10, Proc, nil, nil]}, %q{
509def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
510  x, y = :x, :y if $foo
511  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
512end
513; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10){}}
514
515assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8, 9], 10, 11, Proc, nil, nil]}, %q{
516def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
517  x, y = :x, :y if $foo
518  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
519end
520; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11){}}
521
522assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, nil, nil]}, %q{
523def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
524  x, y = :x, :y if $foo
525  [m1, m2, o1, o2, r, p1, p2, x, y]
526end
527; m(1, 2, 3, 4)}
528
529assert_equal %q{[1, 2, 3, :o2, [], 4, 5, nil, nil]}, %q{
530def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
531  x, y = :x, :y if $foo
532  [m1, m2, o1, o2, r, p1, p2, x, y]
533end
534; m(1, 2, 3, 4, 5)}
535
536assert_equal %q{[1, 2, 3, 4, [], 5, 6, nil, nil]}, %q{
537def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
538  x, y = :x, :y if $foo
539  [m1, m2, o1, o2, r, p1, p2, x, y]
540end
541; m(1, 2, 3, 4, 5, 6)}
542
543
544#
545# super
546#
547=begin
548# below programs are generated by this program:
549
550BASE = <<EOS__
551class C0; def m *args; [:C0_m, args]; end; end
552class C1 < C0; <TEST>; super; end; end
553EOS__
554
555tests = {
556%q{
557  def m
558} => %q{
559  C1.new.m
560},
561#
562%q{
563  def m a
564} => %q{
565  C1.new.m 1
566},
567%q{
568  def m a
569    a = :a
570} => %q{
571  C1.new.m 1
572},
573#
574%q{
575  def m a, o=:o
576} => %q{
577  C1.new.m 1
578  C1.new.m 1, 2
579},
580%q{
581  def m a, o=:o
582    a = :a
583} => %q{
584  C1.new.m 1
585  C1.new.m 1, 2
586},
587%q{
588  def m a, o=:o
589    o = :x
590} => %q{
591  C1.new.m 1
592  C1.new.m 1, 2
593},
594#
595%q{
596  def m a, *r
597} => %q{
598  C1.new.m 1
599  C1.new.m 1, 2
600  C1.new.m 1, 2, 3
601},
602%q{
603  def m a, *r
604    r = [:x, :y]
605} => %q{
606  C1.new.m 1
607  C1.new.m 1, 2
608  C1.new.m 1, 2, 3
609},
610#
611%q{
612  def m a, o=:o, *r
613} => %q{
614  C1.new.m 1
615  C1.new.m 1, 2
616  C1.new.m 1, 2, 3
617  C1.new.m 1, 2, 3, 4
618},
619#
620%q{
621  def m a, o=:o, *r, &b
622} => %q{
623  C1.new.m 1
624  C1.new.m 1, 2
625  C1.new.m 1, 2, 3
626  C1.new.m 1, 2, 3, 4
627  C1.new.m(1){}
628  C1.new.m(1, 2){}
629  C1.new.m(1, 2, 3){}
630  C1.new.m(1, 2, 3, 4){}
631},
632#
633"def m(m1, m2, o1=:o1, o2=:o2, p1, p2)" =>
634%q{
635C1.new.m(1,2,3,4)
636C1.new.m(1,2,3,4,5)
637C1.new.m(1,2,3,4,5,6)
638},
639#
640"def m(m1, m2, *r, p1, p2)" =>
641%q{
642C1.new.m(1,2,3,4)
643C1.new.m(1,2,3,4,5)
644C1.new.m(1,2,3,4,5,6)
645C1.new.m(1,2,3,4,5,6,7)
646C1.new.m(1,2,3,4,5,6,7,8)
647},
648#
649"def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)" =>
650%q{
651C1.new.m(1,2,3,4)
652C1.new.m(1,2,3,4,5)
653C1.new.m(1,2,3,4,5,6)
654C1.new.m(1,2,3,4,5,6,7)
655C1.new.m(1,2,3,4,5,6,7,8)
656C1.new.m(1,2,3,4,5,6,7,8,9)
657},
658
659###
660}
661
662
663tests.each{|setup, methods| setup = setup.dup; setup.strip!
664  setup = BASE.gsub(/<TEST>/){setup}
665  methods.split(/\n/).each{|m| m = m.dup; m.strip!
666    next if m.empty?
667    expr = "#{setup}; #{m}"
668    result = eval(expr)
669    puts "assert_equal %q{#{result.inspect}}, %q{\n#{expr}}"
670    puts
671  }
672}
673
674=end
675
676assert_equal %q{[:C0_m, [1, 2, :o1, :o2, 3, 4]]}, %q{
677class C0; def m *args; [:C0_m, args]; end; end
678class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
679; C1.new.m(1,2,3,4)}
680
681assert_equal %q{[:C0_m, [1, 2, 3, :o2, 4, 5]]}, %q{
682class C0; def m *args; [:C0_m, args]; end; end
683class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
684; C1.new.m(1,2,3,4,5)}
685
686assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, %q{
687class C0; def m *args; [:C0_m, args]; end; end
688class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
689; C1.new.m(1,2,3,4,5,6)}
690
691assert_equal %q{[:C0_m, [1, :o]]}, %q{
692class C0; def m *args; [:C0_m, args]; end; end
693class C1 < C0; def m a, o=:o, *r; super; end; end
694; C1.new.m 1}
695
696assert_equal %q{[:C0_m, [1, 2]]}, %q{
697class C0; def m *args; [:C0_m, args]; end; end
698class C1 < C0; def m a, o=:o, *r; super; end; end
699; C1.new.m 1, 2}
700
701assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
702class C0; def m *args; [:C0_m, args]; end; end
703class C1 < C0; def m a, o=:o, *r; super; end; end
704; C1.new.m 1, 2, 3}
705
706assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
707class C0; def m *args; [:C0_m, args]; end; end
708class C1 < C0; def m a, o=:o, *r; super; end; end
709; C1.new.m 1, 2, 3, 4}
710
711assert_equal %q{[:C0_m, [:a]]}, %q{
712class C0; def m *args; [:C0_m, args]; end; end
713class C1 < C0; def m a
714    a = :a; super; end; end
715; C1.new.m 1}
716
717assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
718class C0; def m *args; [:C0_m, args]; end; end
719class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
720; C1.new.m(1,2,3,4)}
721
722assert_equal %q{[:C0_m, [1, 2, 3, 4, 5]]}, %q{
723class C0; def m *args; [:C0_m, args]; end; end
724class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
725; C1.new.m(1,2,3,4,5)}
726
727assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, %q{
728class C0; def m *args; [:C0_m, args]; end; end
729class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
730; C1.new.m(1,2,3,4,5,6)}
731
732assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7]]}, %q{
733class C0; def m *args; [:C0_m, args]; end; end
734class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
735; C1.new.m(1,2,3,4,5,6,7)}
736
737assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8]]}, %q{
738class C0; def m *args; [:C0_m, args]; end; end
739class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
740; C1.new.m(1,2,3,4,5,6,7,8)}
741
742assert_equal %q{[:C0_m, [1, :o]]}, %q{
743class C0; def m *args; [:C0_m, args]; end; end
744class C1 < C0; def m a, o=:o, *r, &b; super; end; end
745; C1.new.m 1}
746
747assert_equal %q{[:C0_m, [1, 2]]}, %q{
748class C0; def m *args; [:C0_m, args]; end; end
749class C1 < C0; def m a, o=:o, *r, &b; super; end; end
750; C1.new.m 1, 2}
751
752assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
753class C0; def m *args; [:C0_m, args]; end; end
754class C1 < C0; def m a, o=:o, *r, &b; super; end; end
755; C1.new.m 1, 2, 3}
756
757assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
758class C0; def m *args; [:C0_m, args]; end; end
759class C1 < C0; def m a, o=:o, *r, &b; super; end; end
760; C1.new.m 1, 2, 3, 4}
761
762assert_equal %q{[:C0_m, [1, :o]]}, %q{
763class C0; def m *args; [:C0_m, args]; end; end
764class C1 < C0; def m a, o=:o, *r, &b; super; end; end
765; C1.new.m(1){}}
766
767assert_equal %q{[:C0_m, [1, 2]]}, %q{
768class C0; def m *args; [:C0_m, args]; end; end
769class C1 < C0; def m a, o=:o, *r, &b; super; end; end
770; C1.new.m(1, 2){}}
771
772assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
773class C0; def m *args; [:C0_m, args]; end; end
774class C1 < C0; def m a, o=:o, *r, &b; super; end; end
775; C1.new.m(1, 2, 3){}}
776
777assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
778class C0; def m *args; [:C0_m, args]; end; end
779class C1 < C0; def m a, o=:o, *r, &b; super; end; end
780; C1.new.m(1, 2, 3, 4){}}
781
782assert_equal %q{[:C0_m, [1, :x]]}, %q{
783class C0; def m *args; [:C0_m, args]; end; end
784class C1 < C0; def m a, o=:o
785    o = :x; super; end; end
786; C1.new.m 1}
787
788assert_equal %q{[:C0_m, [1, :x]]}, %q{
789class C0; def m *args; [:C0_m, args]; end; end
790class C1 < C0; def m a, o=:o
791    o = :x; super; end; end
792; C1.new.m 1, 2}
793
794assert_equal %q{[:C0_m, [:a, :o]]}, %q{
795class C0; def m *args; [:C0_m, args]; end; end
796class C1 < C0; def m a, o=:o
797    a = :a; super; end; end
798; C1.new.m 1}
799
800assert_equal %q{[:C0_m, [:a, 2]]}, %q{
801class C0; def m *args; [:C0_m, args]; end; end
802class C1 < C0; def m a, o=:o
803    a = :a; super; end; end
804; C1.new.m 1, 2}
805
806assert_equal %q{[:C0_m, [1]]}, %q{
807class C0; def m *args; [:C0_m, args]; end; end
808class C1 < C0; def m a; super; end; end
809; C1.new.m 1}
810
811assert_equal %q{[:C0_m, [1, :x, :y]]}, %q{
812class C0; def m *args; [:C0_m, args]; end; end
813class C1 < C0; def m a, *r
814    r = [:x, :y]; super; end; end
815; C1.new.m 1}
816
817assert_equal %q{[:C0_m, [1, :x, :y]]}, %q{
818class C0; def m *args; [:C0_m, args]; end; end
819class C1 < C0; def m a, *r
820    r = [:x, :y]; super; end; end
821; C1.new.m 1, 2}
822
823assert_equal %q{[:C0_m, [1, :x, :y]]}, %q{
824class C0; def m *args; [:C0_m, args]; end; end
825class C1 < C0; def m a, *r
826    r = [:x, :y]; super; end; end
827; C1.new.m 1, 2, 3}
828
829assert_equal %q{[:C0_m, [1, 2, :o1, :o2, 3, 4]]}, %q{
830class C0; def m *args; [:C0_m, args]; end; end
831class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
832; C1.new.m(1,2,3,4)}
833
834assert_equal %q{[:C0_m, [1, 2, 3, :o2, 4, 5]]}, %q{
835class C0; def m *args; [:C0_m, args]; end; end
836class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
837; C1.new.m(1,2,3,4,5)}
838
839assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, %q{
840class C0; def m *args; [:C0_m, args]; end; end
841class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
842; C1.new.m(1,2,3,4,5,6)}
843
844assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7]]}, %q{
845class C0; def m *args; [:C0_m, args]; end; end
846class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
847; C1.new.m(1,2,3,4,5,6,7)}
848
849assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8]]}, %q{
850class C0; def m *args; [:C0_m, args]; end; end
851class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
852; C1.new.m(1,2,3,4,5,6,7,8)}
853
854assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8, 9]]}, %q{
855class C0; def m *args; [:C0_m, args]; end; end
856class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
857; C1.new.m(1,2,3,4,5,6,7,8,9)}
858
859assert_equal %q{[:C0_m, [1]]}, %q{
860class C0; def m *args; [:C0_m, args]; end; end
861class C1 < C0; def m a, *r; super; end; end
862; C1.new.m 1}
863
864assert_equal %q{[:C0_m, [1, 2]]}, %q{
865class C0; def m *args; [:C0_m, args]; end; end
866class C1 < C0; def m a, *r; super; end; end
867; C1.new.m 1, 2}
868
869assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
870class C0; def m *args; [:C0_m, args]; end; end
871class C1 < C0; def m a, *r; super; end; end
872; C1.new.m 1, 2, 3}
873
874assert_equal %q{[:C0_m, []]}, %q{
875class C0; def m *args; [:C0_m, args]; end; end
876class C1 < C0; def m; super; end; end
877; C1.new.m}
878
879assert_equal %q{[:C0_m, [1, :o]]}, %q{
880class C0; def m *args; [:C0_m, args]; end; end
881class C1 < C0; def m a, o=:o; super; end; end
882; C1.new.m 1}
883
884assert_equal %q{[:C0_m, [1, 2]]}, %q{
885class C0; def m *args; [:C0_m, args]; end; end
886class C1 < C0; def m a, o=:o; super; end; end
887; C1.new.m 1, 2}
888
889assert_equal %q{[:ok, :ok, :ok, :ok, :ok, :ok, :ng, :ng]}, %q{
890  $ans = []
891  class Foo
892    def m
893    end
894  end
895
896  c1 = c2 = nil
897
898  lambda{
899    $SAFE = 4
900    c1 = Class.new{
901      def m
902      end
903    }
904    c2 = Class.new(Foo){
905      alias mm m
906    }
907  }.call
908
909  def test
910    begin
911      yield
912    rescue SecurityError
913      $ans << :ok
914    else
915      $ans << :ng
916    end
917  end
918
919  o1 = c1.new
920  o2 = c2.new
921
922  test{o1.m}
923  test{o2.mm}
924  test{o1.send :m}
925  test{o2.send :mm}
926  test{o1.public_send :m}
927  test{o2.public_send :mm}
928  test{o1.method(:m).call}
929  test{o2.method(:mm).call}
930  $ans
931}
932
933assert_equal 'ok', %q{
934  class C
935    def x=(n)
936    end
937    def m
938      self.x = :ok
939    end
940  end
941  C.new.m
942}
943
944assert_equal 'ok', %q{
945  proc{
946    $SAFE = 1
947    class C
948      def m
949        :ok
950      end
951    end
952  }.call
953  C.new.m
954}, '[ruby-core:11998]'
955
956assert_equal 'ok', %q{
957  proc{
958    $SAFE = 2
959    class C
960      def m
961        :ok
962      end
963    end
964  }.call
965  C.new.m
966}, '[ruby-core:11998]'
967
968assert_equal 'ok', %q{
969  proc{
970    $SAFE = 3
971    class C
972      def m
973        :ng
974      end
975    end
976  }.call
977  begin
978    C.new.m
979  rescue SecurityError
980    :ok
981  end
982}, '[ruby-core:11998]'
983
984assert_equal 'ok', %q{
985  class B
986    def m() :fail end
987  end
988  class C < B
989    undef m
990    begin
991      remove_method :m
992    rescue NameError
993    end
994  end
995  begin
996    C.new.m
997  rescue NameError
998    :ok
999  end
1000}, '[ruby-dev:31816], [ruby-dev:31817]'
1001
1002assert_normal_exit %q{
1003  begin
1004    Process.setrlimit(Process::RLIMIT_STACK, 4_206_592)
1005    # FreeBSD SEGVs this less than 4M + 12K bytes.
1006  rescue Exception
1007    exit
1008  end
1009  class C
1010    attr "a" * (10*1024*1024)
1011  end
1012}, '[ruby-dev:31818]'
1013
1014assert_equal 'ok', %q{
1015  class Module
1016    def define_method2(name, &block)
1017      define_method(name, &block)
1018    end
1019  end
1020  class C
1021    define_method2(:m) {|x, y| :fail }
1022  end
1023  begin
1024    C.new.m([1,2])
1025  rescue ArgumentError
1026    :ok
1027  end
1028}
1029
1030assert_not_match /method_missing/, %q{
1031  STDERR.reopen(STDOUT)
1032  variable_or_mehtod_not_exist
1033}
1034
1035assert_equal '[false, false, false, false, true, true]', %q{
1036  class C
1037    define_method(:foo) {
1038      block_given?
1039    }
1040  end
1041
1042  C.new.foo {}
1043
1044  class D
1045    def foo
1046      D.module_eval{
1047        define_method(:m1){
1048          block_given?
1049        }
1050      }
1051    end
1052    def bar
1053      D.module_eval{
1054        define_method(:m2){
1055          block_given?
1056        }
1057      }
1058    end
1059  end
1060
1061  D.new.foo
1062  D.new.bar{}
1063  [C.new.foo, C.new.foo{}, D.new.m1, D.new.m1{}, D.new.m2, D.new.m2{}]
1064}, '[ruby-core:14813]'
1065
1066assert_equal 'ok', %q{
1067  class Foo
1068    define_method(:foo) do |&b|
1069      b.call
1070    end
1071  end
1072  Foo.new.foo do
1073    break :ok
1074  end
1075}, '[ruby-dev:36028]'
1076
1077assert_equal '[1, 2, [3, 4]]', %q{
1078  def regular(a, b, *c)
1079    [a, b, c]
1080  end
1081  regular(*[], 1, *[], *[2, 3], *[], 4)
1082}, '[ruby-core:19413]'
1083
1084assert_equal '[1, [:foo, 3, 4, :foo]]', %q{
1085  def regular(a, *b)
1086    [a, b]
1087  end
1088  a = b = [:foo]
1089  regular(1, *a, *[3, 4], *b)
1090}
1091
1092assert_equal '["B", "A"]', %q{
1093  class A
1094    def m
1095      'A'
1096    end
1097  end
1098
1099  class B < A
1100    define_method(:m) do
1101      ['B', super()]
1102    end
1103  end
1104
1105  class C < B
1106  end
1107
1108  C.new.m
1109}
1110
1111assert_equal 'ok', %q{
1112  module Foo
1113    def foo
1114      begin
1115        super
1116      rescue NoMethodError
1117        :ok
1118      end
1119    end
1120    module_function :foo
1121  end
1122  Foo.foo
1123}, '[ruby-dev:37587]'
1124
1125assert_equal 'Object#foo', %q{
1126  class Object
1127    def self.foo
1128      "Object.foo"
1129    end
1130    def foo
1131      "Object#foo"
1132    end
1133  end
1134
1135  module Foo
1136    def foo
1137      begin
1138        super
1139      rescue NoMethodError
1140        :ok
1141      end
1142    end
1143    module_function :foo
1144  end
1145  Foo.foo
1146}, '[ruby-dev:37587]'
1147
1148assert_normal_exit %q{
1149  class BasicObject
1150    remove_method :method_missing
1151  end
1152  begin
1153    "a".lalala!
1154  rescue NoMethodError => e
1155    e.message == "undefined method `lalala!' for \"a\":String" ? :ok : :ng
1156  end
1157}, '[ruby-core:22298]'
1158
1159assert_equal 'ok', %q{
1160  "hello"[0] ||= "H"
1161  "ok"
1162}
1163
1164assert_equal 'ok', %q{
1165  "hello"[0, 1] ||= "H"
1166  "ok"
1167}
1168
1169assert_equal 'ok', %q{
1170  class C
1171    define_method(:foo) do
1172      C.class_eval { remove_method(:foo) }
1173      super()
1174    end
1175  end
1176  begin
1177    C.new.foo
1178  rescue NoMethodError
1179    'ok'
1180  end
1181}
1182assert_equal 'ok', %q{
1183  [0][0, &proc{}] += 21
1184  'ok'
1185}, '[ruby-core:30534]'
1186
1187# should not cache when splat
1188assert_equal 'ok', %q{
1189  class C
1190    attr_reader :a
1191    def initialize
1192      @a = 1
1193    end
1194  end
1195
1196  def m *args
1197    C.new.a(*args)
1198  end
1199
1200  m()
1201  begin
1202    m(1)
1203  rescue ArgumentError
1204    'ok'
1205  end
1206}
1207
1208assert_equal 'DC', %q{
1209  $result = []
1210
1211  class C
1212    def foo *args
1213      $result << 'C'
1214    end
1215  end
1216  class D
1217    def foo *args
1218      $result << 'D'
1219    end
1220  end
1221
1222  o1 = $o1 = C.new
1223  o2 = $o2 = D.new
1224
1225  args = Object.new
1226  def args.to_a
1227    test1 $o2, nil
1228    []
1229  end
1230  def test1 o, args
1231    o.foo(*args)
1232  end
1233  test1 o1, args
1234  $result.join
1235}
1236
1237assert_equal 'DC', %q{
1238  $result = []
1239
1240  class C
1241    def foo *args
1242      $result << 'C'
1243    end
1244  end
1245  class D
1246    def foo *args
1247      $result << 'D'
1248    end
1249  end
1250
1251  o1 = $o1 = C.new
1252  o2 = $o2 = D.new
1253
1254  block = Object.new
1255  def block.to_proc
1256    test2 $o2, %w(a, b, c), nil
1257    Proc.new{}
1258  end
1259  def test2 o, args, block
1260    o.foo(*args, &block)
1261  end
1262  test2 o1, [], block
1263  $result.join
1264}
1265