← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ruby1.9/intrepid-updates

« back to all changes in this revision

Viewing changes to bootstraptest/test_method.rb

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2007-09-04 16:01:17 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20070904160117-i15zckg2nhxe9fyw
Tags: 1.9.0+20070830-2ubuntu1
* Sync from Debian; remaining changes:
  - Add -g to CFLAGS.
* Fixes build failure on ia64.
* Fixes build failure with gcc-4.2 on lpia.
* Robustify check for target_os, fixing build failure on lpia.
* Set Ubuntu maintainer address.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bootstraptest/test_method.rb
1
1
# regular argument
2
2
assert_equal '1',       'def m() 1 end; m()'
3
3
assert_equal '1',       'def m(a) a end; m(1)'
4
 
assert_equal '1',       'def m(a,b) a end; m(1,7)'
5
 
assert_equal '1',       'def m(a,b) b end; m(7,1)'
6
 
assert_equal '1',       'def m(a,b,c) a end; m(1,7,7)'
7
 
assert_equal '1',       'def m(a,b,c) b end; m(7,1,7)'
8
 
assert_equal '1',       'def m(a,b,c) c end; m(7,7,1)'
 
4
assert_equal '[1, 2]',  'def m(a,b) [a, b] end; m(1,2)'
 
5
assert_equal '[1, 2, 3]', 'def m(a,b,c) [a, b, c] end; m(1,2,3)'
 
6
assert_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
 
 
15
assert_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
}
9
23
 
10
24
# default argument
11
25
assert_equal '1',       'def m(x=1) x end; m()'
302
316
assert_equal '1',       %q( class C; def m() 7 end; private :m end
303
317
                            begin C.new.send(:m); rescue NoMethodError; 1 end )
304
318
assert_equal '1',       %q( class C; def m() 1 end; private :m end
305
 
                            C.new.funcall(:m) )
 
319
                            C.new.send!(:m) )
 
320
 
 
321
# with block
 
322
assert_equal '[[:ok1, :foo], [:ok2, :foo, :bar]]',
 
323
%q{
 
324
  class C
 
325
    def [](a)
 
326
      $ary << [yield, a]
 
327
    end
 
328
    def []=(a, b)
 
329
      $ary << [yield, a, b]
 
330
    end
 
331
  end
 
332
 
 
333
  $ary = []
 
334
  C.new[:foo, &lambda{:ok1}]
 
335
  C.new[:foo, &lambda{:ok2}] = :bar
 
336
  $ary
 
337
}
 
338
 
 
339
# with
 
340
assert_equal '[:ok1, [:ok2, 11]]', %q{
 
341
  class C
 
342
    def []
 
343
      $ary << :ok1
 
344
      10
 
345
    end
 
346
    def []=(a)
 
347
      $ary << [:ok2, a]
 
348
    end
 
349
  end
 
350
  $ary = []
 
351
  C.new[]+=1
 
352
  $ary
 
353
}
 
354
 
 
355
# splat and block arguments
 
356
assert_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{
 
357
def m(*args, &b)
 
358
  $result << [args, b.class]
 
359
end
 
360
$result = []
 
361
ary = [:x, :y, :z]
 
362
obj = :obj
 
363
b = Proc.new{}
 
364
 
 
365
m(*ary)
 
366
m(1,*ary)
 
367
m(1,2,*ary)
 
368
m(*obj)
 
369
m(1,*obj)
 
370
m(1,2,*obj)
 
371
m(){}
 
372
m(1){}
 
373
m(1,2){}
 
374
m(&b)
 
375
m(1,&b)
 
376
m(1,2,&b)
 
377
m(*ary,&b)
 
378
m(1,*ary,&b)
 
379
m(1,2,*ary,&b)
 
380
$result
 
381
}
 
382
 
 
383
# post test
 
384
assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, NilClass, nil, nil]}, %q{
 
385
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
386
  x, y = :x, :y if $foo
 
387
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
388
end
 
389
; m(1, 2, 3, 4)}
 
390
 
 
391
assert_equal %q{[1, 2, 3, :o2, [], 4, 5, NilClass, nil, nil]}, %q{
 
392
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
393
  x, y = :x, :y if $foo
 
394
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
395
end
 
396
; m(1, 2, 3, 4, 5)}
 
397
 
 
398
assert_equal %q{[1, 2, 3, 4, [], 5, 6, NilClass, nil, nil]}, %q{
 
399
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
400
  x, y = :x, :y if $foo
 
401
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
402
end
 
403
; m(1, 2, 3, 4, 5, 6)}
 
404
 
 
405
assert_equal %q{[1, 2, 3, 4, [5], 6, 7, NilClass, nil, nil]}, %q{
 
406
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
407
  x, y = :x, :y if $foo
 
408
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
409
end
 
410
; m(1, 2, 3, 4, 5, 6, 7)}
 
411
 
 
412
assert_equal %q{[1, 2, 3, 4, [5, 6], 7, 8, NilClass, nil, nil]}, %q{
 
413
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
414
  x, y = :x, :y if $foo
 
415
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
416
end
 
417
; m(1, 2, 3, 4, 5, 6, 7, 8)}
 
418
 
 
419
assert_equal %q{[1, 2, 3, 4, [5, 6, 7], 8, 9, NilClass, nil, nil]}, %q{
 
420
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
421
  x, y = :x, :y if $foo
 
422
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
423
end
 
424
; m(1, 2, 3, 4, 5, 6, 7, 8, 9)}
 
425
 
 
426
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8], 9, 10, NilClass, nil, nil]}, %q{
 
427
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
428
  x, y = :x, :y if $foo
 
429
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
430
end
 
431
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)}
 
432
 
 
433
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8, 9], 10, 11, NilClass, nil, nil]}, %q{
 
434
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
435
  x, y = :x, :y if $foo
 
436
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
437
end
 
438
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)}
 
439
 
 
440
assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, Proc, nil, nil]}, %q{
 
441
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
442
  x, y = :x, :y if $foo
 
443
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
444
end
 
445
; m(1, 2, 3, 4){}}
 
446
 
 
447
assert_equal %q{[1, 2, 3, :o2, [], 4, 5, Proc, nil, nil]}, %q{
 
448
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
449
  x, y = :x, :y if $foo
 
450
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
451
end
 
452
; m(1, 2, 3, 4, 5){}}
 
453
 
 
454
assert_equal %q{[1, 2, 3, 4, [], 5, 6, Proc, nil, nil]}, %q{
 
455
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
456
  x, y = :x, :y if $foo
 
457
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
458
end
 
459
; m(1, 2, 3, 4, 5, 6){}}
 
460
 
 
461
assert_equal %q{[1, 2, 3, 4, [5], 6, 7, Proc, nil, nil]}, %q{
 
462
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
463
  x, y = :x, :y if $foo
 
464
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
465
end
 
466
; m(1, 2, 3, 4, 5, 6, 7){}}
 
467
 
 
468
assert_equal %q{[1, 2, 3, 4, [5, 6], 7, 8, Proc, nil, nil]}, %q{
 
469
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
470
  x, y = :x, :y if $foo
 
471
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
472
end
 
473
; m(1, 2, 3, 4, 5, 6, 7, 8){}}
 
474
 
 
475
assert_equal %q{[1, 2, 3, 4, [5, 6, 7], 8, 9, Proc, nil, nil]}, %q{
 
476
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
477
  x, y = :x, :y if $foo
 
478
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
479
end
 
480
; m(1, 2, 3, 4, 5, 6, 7, 8, 9){}}
 
481
 
 
482
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8], 9, 10, Proc, nil, nil]}, %q{
 
483
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
484
  x, y = :x, :y if $foo
 
485
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
486
end
 
487
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10){}}
 
488
 
 
489
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8, 9], 10, 11, Proc, nil, nil]}, %q{
 
490
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
 
491
  x, y = :x, :y if $foo
 
492
  [m1, m2, o1, o2, r, p1, p2, b.class, x, y]
 
493
end
 
494
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11){}}
 
495
 
 
496
assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, nil, nil]}, %q{
 
497
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
 
498
  x, y = :x, :y if $foo
 
499
  [m1, m2, o1, o2, r, p1, p2, x, y]
 
500
end
 
501
; m(1, 2, 3, 4)}
 
502
 
 
503
assert_equal %q{[1, 2, 3, :o2, [], 4, 5, nil, nil]}, %q{
 
504
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
 
505
  x, y = :x, :y if $foo
 
506
  [m1, m2, o1, o2, r, p1, p2, x, y]
 
507
end
 
508
; m(1, 2, 3, 4, 5)}
 
509
 
 
510
assert_equal %q{[1, 2, 3, 4, [], 5, 6, nil, nil]}, %q{
 
511
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
 
512
  x, y = :x, :y if $foo
 
513
  [m1, m2, o1, o2, r, p1, p2, x, y]
 
514
end
 
515
; m(1, 2, 3, 4, 5, 6)}
 
516
 
 
517
 
 
518
#
 
519
# super
 
520
#
 
521
=begin
 
522
# below programs are generated by this program:
 
523
 
 
524
BASE = <<EOS__
 
525
class C0; def m *args; [:C0_m, args]; end; end
 
526
class C1 < C0; <TEST>; super; end; end
 
527
EOS__
 
528
 
 
529
tests = {
 
530
%q{
 
531
  def m
 
532
} => %q{
 
533
  C1.new.m
 
534
},
 
535
#
 
536
%q{
 
537
  def m a
 
538
} => %q{
 
539
  C1.new.m 1
 
540
},
 
541
%q{
 
542
  def m a
 
543
    a = :a
 
544
} => %q{
 
545
  C1.new.m 1
 
546
},
 
547
#
 
548
%q{
 
549
  def m a, o=:o
 
550
} => %q{
 
551
  C1.new.m 1
 
552
  C1.new.m 1, 2
 
553
},
 
554
%q{
 
555
  def m a, o=:o
 
556
    a = :a
 
557
} => %q{
 
558
  C1.new.m 1
 
559
  C1.new.m 1, 2
 
560
},
 
561
%q{
 
562
  def m a, o=:o
 
563
    o = :x
 
564
} => %q{
 
565
  C1.new.m 1
 
566
  C1.new.m 1, 2
 
567
},
 
568
#
 
569
%q{
 
570
  def m a, *r
 
571
} => %q{
 
572
  C1.new.m 1
 
573
  C1.new.m 1, 2
 
574
  C1.new.m 1, 2, 3
 
575
},
 
576
%q{
 
577
  def m a, *r
 
578
    r = [:x, :y]
 
579
} => %q{
 
580
  C1.new.m 1
 
581
  C1.new.m 1, 2
 
582
  C1.new.m 1, 2, 3
 
583
},
 
584
#
 
585
%q{
 
586
  def m a, o=:o, *r
 
587
} => %q{
 
588
  C1.new.m 1
 
589
  C1.new.m 1, 2
 
590
  C1.new.m 1, 2, 3
 
591
  C1.new.m 1, 2, 3, 4
 
592
},
 
593
#
 
594
%q{
 
595
  def m a, o=:o, *r, &b
 
596
} => %q{
 
597
  C1.new.m 1
 
598
  C1.new.m 1, 2
 
599
  C1.new.m 1, 2, 3
 
600
  C1.new.m 1, 2, 3, 4
 
601
  C1.new.m(1){}
 
602
  C1.new.m(1, 2){}
 
603
  C1.new.m(1, 2, 3){}
 
604
  C1.new.m(1, 2, 3, 4){}
 
605
},
 
606
#
 
607
"def m(m1, m2, o1=:o1, o2=:o2, p1, p2)" =>
 
608
%q{
 
609
C1.new.m(1,2,3,4)
 
610
C1.new.m(1,2,3,4,5)
 
611
C1.new.m(1,2,3,4,5,6)
 
612
},
 
613
#
 
614
"def m(m1, m2, *r, p1, p2)" =>
 
615
%q{
 
616
C1.new.m(1,2,3,4)
 
617
C1.new.m(1,2,3,4,5)
 
618
C1.new.m(1,2,3,4,5,6)
 
619
C1.new.m(1,2,3,4,5,6,7)
 
620
C1.new.m(1,2,3,4,5,6,7,8)
 
621
},
 
622
#
 
623
"def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)" =>
 
624
%q{
 
625
C1.new.m(1,2,3,4)
 
626
C1.new.m(1,2,3,4,5)
 
627
C1.new.m(1,2,3,4,5,6)
 
628
C1.new.m(1,2,3,4,5,6,7)
 
629
C1.new.m(1,2,3,4,5,6,7,8)
 
630
C1.new.m(1,2,3,4,5,6,7,8,9)
 
631
},
 
632
 
 
633
###
 
634
}
 
635
 
 
636
 
 
637
tests.each{|setup, methods| setup = setup.dup; setup.strip!
 
638
  setup = BASE.gsub(/<TEST>/){setup}
 
639
  methods.split(/\n/).each{|m| m = m.dup; m.strip!
 
640
    next if m.empty?
 
641
    expr = "#{setup}; #{m}"
 
642
    result = eval(expr)
 
643
    puts "assert_equal %q{#{result.inspect}}, %q{\n#{expr}}"
 
644
    puts
 
645
  }
 
646
}
 
647
 
 
648
=end
 
649
 
 
650
assert_equal %q{[:C0_m, [1, 2, :o1, :o2, 3, 4]]}, %q{
 
651
class C0; def m *args; [:C0_m, args]; end; end
 
652
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
 
653
; C1.new.m(1,2,3,4)}
 
654
 
 
655
assert_equal %q{[:C0_m, [1, 2, 3, :o2, 4, 5]]}, %q{
 
656
class C0; def m *args; [:C0_m, args]; end; end
 
657
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
 
658
; C1.new.m(1,2,3,4,5)}
 
659
 
 
660
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, %q{
 
661
class C0; def m *args; [:C0_m, args]; end; end
 
662
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
 
663
; C1.new.m(1,2,3,4,5,6)}
 
664
 
 
665
assert_equal %q{[:C0_m, [1, :o]]}, %q{
 
666
class C0; def m *args; [:C0_m, args]; end; end
 
667
class C1 < C0; def m a, o=:o, *r; super; end; end
 
668
; C1.new.m 1}
 
669
 
 
670
assert_equal %q{[:C0_m, [1, 2]]}, %q{
 
671
class C0; def m *args; [:C0_m, args]; end; end
 
672
class C1 < C0; def m a, o=:o, *r; super; end; end
 
673
; C1.new.m 1, 2}
 
674
 
 
675
assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
 
676
class C0; def m *args; [:C0_m, args]; end; end
 
677
class C1 < C0; def m a, o=:o, *r; super; end; end
 
678
; C1.new.m 1, 2, 3}
 
679
 
 
680
assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
 
681
class C0; def m *args; [:C0_m, args]; end; end
 
682
class C1 < C0; def m a, o=:o, *r; super; end; end
 
683
; C1.new.m 1, 2, 3, 4}
 
684
 
 
685
assert_equal %q{[:C0_m, [:a]]}, %q{
 
686
class C0; def m *args; [:C0_m, args]; end; end
 
687
class C1 < C0; def m a
 
688
    a = :a; super; end; end
 
689
; C1.new.m 1}
 
690
 
 
691
assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
 
692
class C0; def m *args; [:C0_m, args]; end; end
 
693
class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
 
694
; C1.new.m(1,2,3,4)}
 
695
 
 
696
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5]]}, %q{
 
697
class C0; def m *args; [:C0_m, args]; end; end
 
698
class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
 
699
; C1.new.m(1,2,3,4,5)}
 
700
 
 
701
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, %q{
 
702
class C0; def m *args; [:C0_m, args]; end; end
 
703
class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
 
704
; C1.new.m(1,2,3,4,5,6)}
 
705
 
 
706
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7]]}, %q{
 
707
class C0; def m *args; [:C0_m, args]; end; end
 
708
class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
 
709
; C1.new.m(1,2,3,4,5,6,7)}
 
710
 
 
711
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8]]}, %q{
 
712
class C0; def m *args; [:C0_m, args]; end; end
 
713
class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
 
714
; C1.new.m(1,2,3,4,5,6,7,8)}
 
715
 
 
716
assert_equal %q{[:C0_m, [1, :o]]}, %q{
 
717
class C0; def m *args; [:C0_m, args]; end; end
 
718
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
719
; C1.new.m 1}
 
720
 
 
721
assert_equal %q{[:C0_m, [1, 2]]}, %q{
 
722
class C0; def m *args; [:C0_m, args]; end; end
 
723
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
724
; C1.new.m 1, 2}
 
725
 
 
726
assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
 
727
class C0; def m *args; [:C0_m, args]; end; end
 
728
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
729
; C1.new.m 1, 2, 3}
 
730
 
 
731
assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
 
732
class C0; def m *args; [:C0_m, args]; end; end
 
733
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
734
; C1.new.m 1, 2, 3, 4}
 
735
 
 
736
assert_equal %q{[:C0_m, [1, :o]]}, %q{
 
737
class C0; def m *args; [:C0_m, args]; end; end
 
738
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
739
; C1.new.m(1){}}
 
740
 
 
741
assert_equal %q{[:C0_m, [1, 2]]}, %q{
 
742
class C0; def m *args; [:C0_m, args]; end; end
 
743
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
744
; C1.new.m(1, 2){}}
 
745
 
 
746
assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
 
747
class C0; def m *args; [:C0_m, args]; end; end
 
748
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
749
; C1.new.m(1, 2, 3){}}
 
750
 
 
751
assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, %q{
 
752
class C0; def m *args; [:C0_m, args]; end; end
 
753
class C1 < C0; def m a, o=:o, *r, &b; super; end; end
 
754
; C1.new.m(1, 2, 3, 4){}}
 
755
 
 
756
assert_equal %q{[:C0_m, [1, :x]]}, %q{
 
757
class C0; def m *args; [:C0_m, args]; end; end
 
758
class C1 < C0; def m a, o=:o
 
759
    o = :x; super; end; end
 
760
; C1.new.m 1}
 
761
 
 
762
assert_equal %q{[:C0_m, [1, :x]]}, %q{
 
763
class C0; def m *args; [:C0_m, args]; end; end
 
764
class C1 < C0; def m a, o=:o
 
765
    o = :x; super; end; end
 
766
; C1.new.m 1, 2}
 
767
 
 
768
assert_equal %q{[:C0_m, [:a, :o]]}, %q{
 
769
class C0; def m *args; [:C0_m, args]; end; end
 
770
class C1 < C0; def m a, o=:o
 
771
    a = :a; super; end; end
 
772
; C1.new.m 1}
 
773
 
 
774
assert_equal %q{[:C0_m, [:a, 2]]}, %q{
 
775
class C0; def m *args; [:C0_m, args]; end; end
 
776
class C1 < C0; def m a, o=:o
 
777
    a = :a; super; end; end
 
778
; C1.new.m 1, 2}
 
779
 
 
780
assert_equal %q{[:C0_m, [1]]}, %q{
 
781
class C0; def m *args; [:C0_m, args]; end; end
 
782
class C1 < C0; def m a; super; end; end
 
783
; C1.new.m 1}
 
784
 
 
785
assert_equal %q{[:C0_m, [1, :x, :y]]}, %q{
 
786
class C0; def m *args; [:C0_m, args]; end; end
 
787
class C1 < C0; def m a, *r
 
788
    r = [:x, :y]; super; end; end
 
789
; C1.new.m 1}
 
790
 
 
791
assert_equal %q{[:C0_m, [1, :x, :y]]}, %q{
 
792
class C0; def m *args; [:C0_m, args]; end; end
 
793
class C1 < C0; def m a, *r
 
794
    r = [:x, :y]; super; end; end
 
795
; C1.new.m 1, 2}
 
796
 
 
797
assert_equal %q{[:C0_m, [1, :x, :y]]}, %q{
 
798
class C0; def m *args; [:C0_m, args]; end; end
 
799
class C1 < C0; def m a, *r
 
800
    r = [:x, :y]; super; end; end
 
801
; C1.new.m 1, 2, 3}
 
802
 
 
803
assert_equal %q{[:C0_m, [1, 2, :o1, :o2, 3, 4]]}, %q{
 
804
class C0; def m *args; [:C0_m, args]; end; end
 
805
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
 
806
; C1.new.m(1,2,3,4)}
 
807
 
 
808
assert_equal %q{[:C0_m, [1, 2, 3, :o2, 4, 5]]}, %q{
 
809
class C0; def m *args; [:C0_m, args]; end; end
 
810
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
 
811
; C1.new.m(1,2,3,4,5)}
 
812
 
 
813
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, %q{
 
814
class C0; def m *args; [:C0_m, args]; end; end
 
815
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
 
816
; C1.new.m(1,2,3,4,5,6)}
 
817
 
 
818
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7]]}, %q{
 
819
class C0; def m *args; [:C0_m, args]; end; end
 
820
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
 
821
; C1.new.m(1,2,3,4,5,6,7)}
 
822
 
 
823
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8]]}, %q{
 
824
class C0; def m *args; [:C0_m, args]; end; end
 
825
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
 
826
; C1.new.m(1,2,3,4,5,6,7,8)}
 
827
 
 
828
assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8, 9]]}, %q{
 
829
class C0; def m *args; [:C0_m, args]; end; end
 
830
class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
 
831
; C1.new.m(1,2,3,4,5,6,7,8,9)}
 
832
 
 
833
assert_equal %q{[:C0_m, [1]]}, %q{
 
834
class C0; def m *args; [:C0_m, args]; end; end
 
835
class C1 < C0; def m a, *r; super; end; end
 
836
; C1.new.m 1}
 
837
 
 
838
assert_equal %q{[:C0_m, [1, 2]]}, %q{
 
839
class C0; def m *args; [:C0_m, args]; end; end
 
840
class C1 < C0; def m a, *r; super; end; end
 
841
; C1.new.m 1, 2}
 
842
 
 
843
assert_equal %q{[:C0_m, [1, 2, 3]]}, %q{
 
844
class C0; def m *args; [:C0_m, args]; end; end
 
845
class C1 < C0; def m a, *r; super; end; end
 
846
; C1.new.m 1, 2, 3}
 
847
 
 
848
assert_equal %q{[:C0_m, []]}, %q{
 
849
class C0; def m *args; [:C0_m, args]; end; end
 
850
class C1 < C0; def m; super; end; end
 
851
; C1.new.m}
 
852
 
 
853
assert_equal %q{[:C0_m, [1, :o]]}, %q{
 
854
class C0; def m *args; [:C0_m, args]; end; end
 
855
class C1 < C0; def m a, o=:o; super; end; end
 
856
; C1.new.m 1}
 
857
 
 
858
assert_equal %q{[:C0_m, [1, 2]]}, %q{
 
859
class C0; def m *args; [:C0_m, args]; end; end
 
860
class C1 < C0; def m a, o=:o; super; end; end
 
861
; C1.new.m 1, 2}
 
862
 
 
863
assert_equal %q{[:ok, :ok, :ok, :ok, :ok, :ok, :ng, :ng]}, %q{
 
864
  $ans = []
 
865
  class Foo
 
866
    def m
 
867
    end
 
868
  end
 
869
 
 
870
  alias send! send unless defined? send!
 
871
 
 
872
  c1 = c2 = nil
 
873
 
 
874
  lambda{
 
875
    $SAFE = 4
 
876
    c1 = Class.new{
 
877
      def m
 
878
      end
 
879
    }
 
880
    c2 = Class.new(Foo){
 
881
      alias mm m
 
882
    }
 
883
  }.call
 
884
 
 
885
  def test
 
886
    begin
 
887
      yield
 
888
    rescue SecurityError
 
889
      $ans << :ok
 
890
    else
 
891
      $ans << :ng
 
892
    end
 
893
  end
 
894
 
 
895
  o1 = c1.new
 
896
  o2 = c2.new
 
897
  
 
898
  test{o1.m}
 
899
  test{o2.mm}
 
900
  test{o1.send :m}
 
901
  test{o2.send :mm}
 
902
  test{o1.send! :m}
 
903
  test{o2.send! :mm}
 
904
  test{o1.method(:m).call}
 
905
  test{o2.method(:mm).call}
 
906
  $ans
 
907
}
 
908
 
 
909
assert_equal 'ok', %q{
 
910
  class C
 
911
    def x=(n)
 
912
    end
 
913
    def m
 
914
      self.x = :ok
 
915
    end
 
916
  end
 
917
  C.new.m
 
918
}
 
919
 
 
920
assert_equal 'ok', %q{
 
921
  proc{
 
922
    $SAFE = 1
 
923
    class C
 
924
      def m
 
925
        :ok
 
926
      end
 
927
    end
 
928
  }.call
 
929
  C.new.m
 
930
}, '[ruby-core:11998]'
 
931
 
 
932
assert_equal 'ok', %q{
 
933
  proc{
 
934
    $SAFE = 2
 
935
    class C
 
936
      def m
 
937
        :ok
 
938
      end
 
939
    end
 
940
  }.call
 
941
  C.new.m
 
942
}, '[ruby-core:11998]'
 
943
 
 
944
assert_equal 'ok', %q{
 
945
  proc{
 
946
    $SAFE = 3
 
947
    class C
 
948
      def m
 
949
        :ng
 
950
      end
 
951
    end
 
952
  }.call
 
953
  begin
 
954
    C.new.m
 
955
  rescue SecurityError
 
956
    :ok
 
957
  end
 
958
}, '[ruby-core:11998]'
 
959