kylefang/RubyMotion
1
0
Fork 0
mirror of https://github.com/zhigang1992/RubyMotion.git synced 2026-04-02 09:31:37 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
bb09fa9e0c86d36f61cb3225cf94de0cf7f549c2
RubyMotion/test/TestSuite/app/test_method.rb
Watson 8f1f8ca514 add two test suites
2012-09-22 21:57:31 +09:00

1186 lines
34 KiB
Ruby
Raw Blame History

test_begin "test_method"
# regular argument
assert_equal '1', proc{ def m() 1 end; m() }
assert_equal '1', proc{ def m(a) a end; m(1) }
assert_equal '[1, 2]', proc{ def m(a,b) [a, b] end; m(1,2) }
assert_equal '[1, 2, 3]', proc{ def m(a,b,c) [a, b, c] end; m(1,2,3) }
assert_equal 'wrong number of arguments (1 for 0)', proc{
def m; end
begin
m(1)
rescue => e
e.message
end
}
assert_equal 'wrong number of arguments (0 for 1)', proc{
def m a; end
begin
m
rescue => e
e.message
end
}
# default argument
assert_equal '1', proc{ def m(x=1) x end; m() }
assert_equal '1', proc{ def m(x=7) x end; m(1) }
assert_equal '1', proc{ def m(a,x=1) x end; m(7) }
assert_equal '1', proc{ def m(a,x=7) x end; m(7,1) }
assert_equal '1', proc{ def m(a,b,x=1) x end; m(7,7) }
assert_equal '1', proc{ def m(a,b,x=7) x end; m(7,7,1) }
assert_equal '1', proc{ def m(a,x=1,y=1) x end; m(7) }
assert_equal '1', proc{ def m(a,x=1,y=1) y end; m(7) }
assert_equal '1', proc{ def m(a,x=7,y=1) x end; m(7,1) }
assert_equal '1', proc{ def m(a,x=7,y=1) y end; m(7,1) }
assert_equal '1', proc{ def m(a,x=7,y=7) x end; m(7,1,1) }
assert_equal '1', proc{ def m(a,x=7,y=7) y end; m(7,1,1) }
# rest argument
assert_equal '[]', proc{ def m(*a) a end; m().inspect }
assert_equal '[1]', proc{ def m(*a) a end; m(1).inspect }
assert_equal '[1, 2]', proc{ def m(*a) a end; m(1,2).inspect }
assert_equal '[]', proc{ def m(x,*a) a end; m(7).inspect }
assert_equal '[1]', proc{ def m(x,*a) a end; m(7,1).inspect }
assert_equal '[1, 2]', proc{ def m(x,*a) a end; m(7,1,2).inspect }
assert_equal '[]', proc{ def m(x,y,*a) a end; m(7,7).inspect }
assert_equal '[1]', proc{ def m(x,y,*a) a end; m(7,7,1).inspect }
assert_equal '[1, 2]', proc{ def m(x,y,*a) a end; m(7,7,1,2).inspect }
assert_equal '[]', proc{ def m(x,y=7,*a) a end; m(7).inspect }
assert_equal '[]', proc{ def m(x,y,z=7,*a) a end; m(7,7).inspect }
assert_equal '[]', proc{ def m(x,y,z=7,*a) a end; m(7,7,7).inspect }
assert_equal '[]', proc{ def m(x,y,z=7,zz=7,*a) a end; m(7,7,7).inspect }
assert_equal '[]', proc{ def m(x,y,z=7,zz=7,*a) a end; m(7,7,7,7).inspect }
assert_equal '1', proc{ def m(x,y,z=7,zz=1,*a) zz end; m(7,7,7).inspect }
assert_equal '1', proc{ def m(x,y,z=7,zz=1,*a) zz end; m(7,7,7).inspect }
assert_equal '1', proc{ def m(x,y,z=7,zz=7,*a) zz end; m(7,7,7,1).inspect }
# block argument
assert_equal 'Proc', proc{ def m(&block) block end; m{}.class }
assert_equal 'nil', proc{ def m(&block) block end; m().inspect }
assert_equal 'Proc', proc{ def m(a,&block) block end; m(7){}.class }
assert_equal 'nil', proc{ def m(a,&block) block end; m(7).inspect }
assert_equal '1', proc{ def m(a,&block) a end; m(1){} }
assert_equal 'Proc', proc{ def m(a,b=nil,&block) block end; m(7){}.class }
assert_equal 'nil', proc{ def m(a,b=nil,&block) block end; m(7).inspect }
assert_equal 'Proc', proc{ def m(a,b=nil,&block) block end; m(7,7){}.class }
assert_equal '1', proc{ def m(a,b=nil,&block) b end; m(7,1){} }
assert_equal 'Proc', proc{ def m(a,b=nil,*c,&block) block end; m(7){}.class }
assert_equal 'nil', proc{ def m(a,b=nil,*c,&block) block end; m(7).inspect }
assert_equal '1', proc{ def m(a,b=nil,*c,&block) a end; m(1).inspect }
assert_equal '1', proc{ def m(a,b=1,*c,&block) b end; m(7).inspect }
assert_equal '1', proc{ def m(a,b=7,*c,&block) b end; m(7,1).inspect }
assert_equal '[1]', proc{ def m(a,b=7,*c,&block) c end; m(7,7,1).inspect }
# splat
assert_equal '1', proc{ def m(a) a end; m(*[1]) }
assert_equal '1', proc{ def m(x,a) a end; m(7,*[1]) }
assert_equal '1', proc{ def m(x,y,a) a end; m(7,7,*[1]) }
assert_equal '1', proc{ def m(a,b) a end; m(*[1,7]) }
assert_equal '1', proc{ def m(a,b) b end; m(*[7,1]) }
assert_equal '1', proc{ def m(x,a,b) b end; m(7,*[7,1]) }
assert_equal '1', proc{ def m(x,y,a,b) b end; m(7,7,*[7,1]) }
assert_equal '1', proc{ def m(a,b,c) a end; m(*[1,7,7]) }
assert_equal '1', proc{ def m(a,b,c) b end; m(*[7,1,7]) }
assert_equal '1', proc{ def m(a,b,c) c end; m(*[7,7,1]) }
assert_equal '1', proc{ def m(x,a,b,c) a end; m(7,*[1,7,7]) }
assert_equal '1', proc{ def m(x,y,a,b,c) a end; m(7,7,*[1,7,7]) }
# hash argument
assert_equal '1', proc{ def m(h) h end; m(7=>1)[7] }
assert_equal '1', proc{ def m(h) h end; m(7=>1).size }
assert_equal '1', proc{ def m(h) h end; m(7=>1, 8=>7)[7] }
assert_equal '2', proc{ def m(h) h end; m(7=>1, 8=>7).size }
assert_equal '1', proc{ def m(h) h end; m(7=>1, 8=>7, 9=>7)[7] }
assert_equal '3', proc{ def m(h) h end; m(7=>1, 8=>7, 9=>7).size }
assert_equal '1', proc{ def m(x,h) h end; m(7, 7=>1)[7] }
assert_equal '1', proc{ def m(x,h) h end; m(7, 7=>1, 8=>7)[7] }
assert_equal '1', proc{ def m(x,h) h end; m(7, 7=>1, 8=>7, 9=>7)[7] }
assert_equal '1', proc{ def m(x,y,h) h end; m(7,7, 7=>1)[7] }
assert_equal '1', proc{ def m(x,y,h) h end; m(7,7, 7=>1, 8=>7)[7] }
assert_equal '1', proc{ def m(x,y,h) h end; m(7,7, 7=>1, 8=>7, 9=>7)[7] }
# block argument
assert_equal '1', proc{ def m(&block) mm(&block) end
def mm() yield 1 end
m {|a| a } }
assert_equal '1', proc{ def m(x,&block) mm(x,&block) end
def mm(x) yield 1 end
m(7) {|a| a } }
assert_equal '1', proc{ def m(x,y,&block) mm(x,y,&block) end
def mm(x,y) yield 1 end
m(7,7) {|a| a } }
# recursive call
assert_equal '1', proc{ def m(n) n == 0 ? 1 : m(n-1) end; m(5) }
# instance method
assert_equal '1', proc{ class C; def m() 1 end end; C.new.m }
assert_equal '1', proc{ class C; def m(a) a end end; C.new.m(1) }
assert_equal '1', proc{ class C; def m(a = 1) a end end; C.new.m }
assert_equal '[1]', proc{ class C; def m(*a) a end end; C.new.m(1).inspect }
assert_equal '1', proc{ class C
def m() mm() end
def mm() 1 end
end
C.new.m }
# singleton method (const)
assert_equal '1', proc{ class C; def C.m() 1 end end; C.m }
assert_equal '1', proc{ class C; def C.m(a) a end end; C.m(1) }
assert_equal '1', proc{ class C; def C.m(a = 1) a end end; C.m }
assert_equal '[1]', proc{ class C; def C.m(*a) a end end; C.m(1).inspect }
assert_equal '1', proc{ class C; end; def C.m() 1 end; C.m }
assert_equal '1', proc{ class C; end; def C.m(a) a end; C.m(1) }
assert_equal '1', proc{ class C; end; def C.m(a = 1) a end; C.m }
assert_equal '[1]', proc{ class C; end; def C.m(*a) a end; C.m(1).inspect }
assert_equal '1', proc{ class C; def m() 7 end end; def C.m() 1 end; C.m }
assert_equal '1', proc{ class C
def C.m() mm() end
def C.mm() 1 end
end
C.m }
# singleton method (lvar)
assert_equal '1', proc{ obj = Object.new; def obj.m() 1 end; obj.m }
assert_equal '1', proc{ obj = Object.new; def obj.m(a) a end; obj.m(1) }
assert_equal '1', proc{ obj = Object.new; def obj.m(a=1) a end; obj.m }
assert_equal '[1]', proc{ obj = Object.new; def obj.m(*a) a end; obj.m(1)}
assert_equal '1', proc{ class C; def m() 7 end; end
obj = C.new
def obj.m() 1 end
obj.m }
# inheritance
assert_equal '1', proc{ class A; def m(a) a end end
class B < A; end
B.new.m(1) }
assert_equal '1', proc{ class A; end
class B < A; def m(a) a end end
B.new.m(1) }
# assert_equal '1', proc{ class A; def m(a) a end end
# class B < A; end
# class C < B; end
# C.new.m(1) }
# include
assert_equal '1', proc{ class A; def m(a) a end end
module M; end
class B < A; include M; end
B.new.m(1) }
assert_equal '1', proc{ class A; end
module M; def m(a) a end end
class B < A; include M; end
B.new.m(1) }
# alias
# assert_equal '1', proc{ def a() 1 end
# alias m a
# m() }
assert_equal '1', proc{ class C
def a() 1 end
alias m a
end
C.new.m }
assert_equal '1', proc{ class C
def a() 1 end
alias :m a
end
C.new.m }
assert_equal '1', proc{ class C
def a() 1 end
alias m :a
end
C.new.m }
assert_equal '1', proc{ class C
def a() 1 end
alias :m :a
end
C.new.m }
assert_equal '1', proc{ class C
def a() 1 end
alias m a
undef a
end
C.new.m }
# undef
assert_equal '1', proc{ class C
def m() end
undef m
end
begin C.new.m; rescue NoMethodError; 1 end }
# assert_equal '1', proc{ class A
# def m() end
# end
# class C < A
# def m() end
# undef m
# end
# begin C.new.m; rescue NoMethodError; 1 end }
assert_equal '1', proc{ class A; def a() end end # [yarv-dev:999]
class B < A
def b() end
undef a, b
end
begin B.new.a; rescue NoMethodError; 1 end }
# assert_equal '1', proc{ class A; def a() end end # [yarv-dev:999]
# class B < A
# def b() end
# undef a, b
# end
# begin B.new.b; rescue NoMethodError; 1 end }
# assert_equal '3', proc{
# def m1
# 1
# end
# alias m2 m1
# alias :"#{'m3'}" m1
# m1 + m2 + m3
# }, '[ruby-dev:32308]'
assert_equal '1', proc{
def foobar
end
undef :"foo#{:bar}"
1
}, '[ruby-dev:32308]'
# assert_equal '1', proc{
# def foobar
# 1
# end
# alias :"bar#{:baz}" :"foo#{:bar}"
# barbaz
# }, '[ruby-dev:32308]'
# private
assert_equal '1', proc{ class C
def m() mm() end
def mm() 1 end
private :mm
end
C.new.m }
assert_equal '1', proc{ class C
def m() 7 end
private :m
end
begin C.m; rescue NoMethodError; 1 end }
assert_equal '1', proc{ class C
def C.m() mm() end
def C.mm() 1 end
private_class_method :mm
end
C.m }
assert_equal '1', proc{ class C
def C.m() 7 end
private_class_method :m
end
begin C.m; rescue NoMethodError; 1 end }
assert_equal '1', proc{ class C; def m() 1 end end
C.new.m # cache
class C
alias mm m; private :mm
end
C.new.m
begin C.new.mm; 7; rescue NoMethodError; 1 end }
# nested method
assert_equal '1', proc{ class C
def m
def mm() 1 end
end
end
C.new.m
C.new.mm }
# assert_equal '1', proc{ class C
# def m
# def mm() 1 end
# end
# end
# instance_eval "C.new.m; C.new.mm" }
# method_missing
# assert_equal ':m', proc{ class C5
# def method_missing(mid, *args) mid end
# end
# C5.new.m.inspect }
# assert_equal ':mm', proc{ class C5
# def method_missing(mid, *args) mid end
# end
# C5.new.mm.inspect }
# assert_equal '[1, 2]', proc{ class C5
# def method_missing(mid, *args) args end
# end
# C5.new.m(1,2).inspect }
# assert_equal '1', proc{ class C5
# def method_missing(mid, *args) yield 1 end
# end
# C5.new.m {|a| a } }
# assert_equal 'nil', proc{ class C5
# def method_missing(mid, *args, &block) block end
# end
# C5.new.m.inspect }
# send
assert_equal '1', proc{ class C; def m() 1 end end;
C.new.__send__(:m) }
assert_equal '1', proc{ class C; def m() 1 end end;
C.new.send(:m) }
assert_equal '1', proc{ class C; def m(a) a end end;
C.new.send(:m,1) }
assert_equal '1', proc{ class C; def m(a,b) a end end;
C.new.send(:m,1,7) }
assert_equal '1', proc{ class C; def m(x,a=1) a end end;
C.new.send(:m,7) }
assert_equal '1', proc{ class C; def m(x,a=7) a end end;
C.new.send(:m,7,1) }
assert_equal '[1, 2]', proc{ class C; def m(*a) a end end;
C.new.send(:m,1,2).inspect }
assert_equal '1', proc{ class C; def m() 7 end; private :m end
begin C.new.public_send(:m); rescue NoMethodError; 1 end }
assert_equal '1', proc{ class C; def m() 1 end; private :m end
C.new.send(:m) }
# with block
# assert_equal '[[:ok1, :foo], [:ok2, :foo, :bar]]',
# proc{
# class C
# def [](a)
# $ary << [yield, a]
# end
# def []=(a, b)
# $ary << [yield, a, b]
# end
# end
# $ary = []
# C.new[:foo, &lambda{:ok1}]
# C.new[:foo, &lambda{:ok2}] = :bar
# $ary
# }
# with
# assert_equal '[:ok1, [:ok2, 11]]', proc{
# class C
# def []
# $ary << :ok1
# 10
# end
# def []=(a)
# $ary << [:ok2, a]
# end
# end
# $ary = []
# C.new[]+=1
# $ary
# }
# splat and block arguments
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]]}, proc{
def m(*args, &b)
$result << [args, b.class]
end
$result = []
ary = [:x, :y, :z]
obj = :obj
b = Proc.new{}
m(*ary)
m(1,*ary)
m(1,2,*ary)
m(*obj)
m(1,*obj)
m(1,2,*obj)
m(){}
m(1){}
m(1,2){}
m(&b)
m(1,&b)
m(1,2,&b)
m(*ary,&b)
m(1,*ary,&b)
m(1,2,*ary,&b)
$result
}
# post test
assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4)}
assert_equal %q{[1, 2, 3, :o2, [], 4, 5, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5)}
assert_equal %q{[1, 2, 3, 4, [], 5, 6, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6)}
assert_equal %q{[1, 2, 3, 4, [5], 6, 7, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7)}
assert_equal %q{[1, 2, 3, 4, [5, 6], 7, 8, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8)}
assert_equal %q{[1, 2, 3, 4, [5, 6, 7], 8, 9, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8, 9)}
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8], 9, 10, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)}
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8, 9], 10, 11, NilClass, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)}
assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4){}}
assert_equal %q{[1, 2, 3, :o2, [], 4, 5, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5){}}
assert_equal %q{[1, 2, 3, 4, [], 5, 6, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6){}}
assert_equal %q{[1, 2, 3, 4, [5], 6, 7, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7){}}
assert_equal %q{[1, 2, 3, 4, [5, 6], 7, 8, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8){}}
assert_equal %q{[1, 2, 3, 4, [5, 6, 7], 8, 9, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8, 9){}}
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8], 9, 10, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10){}}
assert_equal %q{[1, 2, 3, 4, [5, 6, 7, 8, 9], 10, 11, Proc, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2, &b)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, b.class, x, y]
end
; m(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11){}}
assert_equal %q{[1, 2, :o1, :o2, [], 3, 4, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, x, y]
end
; m(1, 2, 3, 4)}
assert_equal %q{[1, 2, 3, :o2, [], 4, 5, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, x, y]
end
; m(1, 2, 3, 4, 5)}
assert_equal %q{[1, 2, 3, 4, [], 5, 6, nil, nil]}, proc{
def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)
x, y = :x, :y if $foo
[m1, m2, o1, o2, r, p1, p2, x, y]
end
; m(1, 2, 3, 4, 5, 6)}
#
# super
#
=begin
# below programs are generated by this program:
BASE = <<EOS__
class C0; def m *args; [:C0_m, args]; end; end
class C1 < C0; <TEST>; super; end; end
EOS__
tests = {
%q{
def m
} => %q{
C1.new.m
},
#
%q{
def m a
} => %q{
C1.new.m 1
},
%q{
def m a
a = :a
} => %q{
C1.new.m 1
},
#
%q{
def m a, o=:o
} => %q{
C1.new.m 1
C1.new.m 1, 2
},
%q{
def m a, o=:o
a = :a
} => %q{
C1.new.m 1
C1.new.m 1, 2
},
%q{
def m a, o=:o
o = :x
} => %q{
C1.new.m 1
C1.new.m 1, 2
},
#
%q{
def m a, *r
} => %q{
C1.new.m 1
C1.new.m 1, 2
C1.new.m 1, 2, 3
},
%q{
def m a, *r
r = [:x, :y]
} => %q{
C1.new.m 1
C1.new.m 1, 2
C1.new.m 1, 2, 3
},
#
%q{
def m a, o=:o, *r
} => %q{
C1.new.m 1
C1.new.m 1, 2
C1.new.m 1, 2, 3
C1.new.m 1, 2, 3, 4
},
#
%q{
def m a, o=:o, *r, &b
} => %q{
C1.new.m 1
C1.new.m 1, 2
C1.new.m 1, 2, 3
C1.new.m 1, 2, 3, 4
C1.new.m(1){}
C1.new.m(1, 2){}
C1.new.m(1, 2, 3){}
C1.new.m(1, 2, 3, 4){}
},
#
"def m(m1, m2, o1=:o1, o2=:o2, p1, p2)" =>
%q{
C1.new.m(1,2,3,4)
C1.new.m(1,2,3,4,5)
C1.new.m(1,2,3,4,5,6)
},
#
"def m(m1, m2, *r, p1, p2)" =>
%q{
C1.new.m(1,2,3,4)
C1.new.m(1,2,3,4,5)
C1.new.m(1,2,3,4,5,6)
C1.new.m(1,2,3,4,5,6,7)
C1.new.m(1,2,3,4,5,6,7,8)
},
#
"def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2)" =>
%q{
C1.new.m(1,2,3,4)
C1.new.m(1,2,3,4,5)
C1.new.m(1,2,3,4,5,6)
C1.new.m(1,2,3,4,5,6,7)
C1.new.m(1,2,3,4,5,6,7,8)
C1.new.m(1,2,3,4,5,6,7,8,9)
},
###
}
tests.each{|setup, methods| setup = setup.dup; setup.strip!
setup = BASE.gsub(/<TEST>/){setup}
methods.split(/\n/).each{|m| m = m.dup; m.strip!
next if m.empty?
expr = "#{setup}; #{m}"
result = eval(expr)
puts "assert_equal %q{#{result.inspect}}, proc{\n#{expr}}"
puts
}
}
=end
# assert_equal %q{[:C0_m, [1, 2, :o1, :o2, 3, 4]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4)}
# assert_equal %q{[:C0_m, [1, 2, 3, :o2, 4, 5]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6)}
# assert_equal %q{[:C0_m, [1, :o]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, 2]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:C0_m, [1, 2, 3]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r; super; end; end
# ; C1.new.m 1, 2, 3}
# assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r; super; end; end
# ; C1.new.m 1, 2, 3, 4}
# assert_equal %q{[:C0_m, [:a]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a
# a = :a; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6,7)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6,7,8)}
# assert_equal %q{[:C0_m, [1, :o]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, 2]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:C0_m, [1, 2, 3]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m 1, 2, 3}
# assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m 1, 2, 3, 4}
# assert_equal %q{[:C0_m, [1, :o]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m(1){}}
# assert_equal %q{[:C0_m, [1, 2]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m(1, 2){}}
# assert_equal %q{[:C0_m, [1, 2, 3]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m(1, 2, 3){}}
# assert_equal %q{[:C0_m, [1, 2, 3, 4]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o, *r, &b; super; end; end
# ; C1.new.m(1, 2, 3, 4){}}
# assert_equal %q{[:C0_m, [1, :x]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o
# o = :x; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, :x]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o
# o = :x; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:C0_m, [:a, :o]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o
# a = :a; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [:a, 2]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o
# a = :a; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:C0_m, [1]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, :x, :y]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, *r
# r = [:x, :y]; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, :x, :y]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, *r
# r = [:x, :y]; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:C0_m, [1, :x, :y]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, *r
# r = [:x, :y]; super; end; end
# ; C1.new.m 1, 2, 3}
# assert_equal %q{[:C0_m, [1, 2, :o1, :o2, 3, 4]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4)}
# assert_equal %q{[:C0_m, [1, 2, 3, :o2, 4, 5]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6,7)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6,7,8)}
# assert_equal %q{[:C0_m, [1, 2, 3, 4, 5, 6, 7, 8, 9]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m(m1, m2, o1=:o1, o2=:o2, *r, p1, p2); super; end; end
# ; C1.new.m(1,2,3,4,5,6,7,8,9)}
# assert_equal %q{[:C0_m, [1]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, *r; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, 2]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, *r; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:C0_m, [1, 2, 3]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, *r; super; end; end
# ; C1.new.m 1, 2, 3}
# assert_equal %q{[:C0_m, []]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m; super; end; end
# ; C1.new.m}
# assert_equal %q{[:C0_m, [1, :o]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o; super; end; end
# ; C1.new.m 1}
# assert_equal %q{[:C0_m, [1, 2]]}, proc{
# class C0; def m *args; [:C0_m, args]; end; end
# class C1 < C0; def m a, o=:o; super; end; end
# ; C1.new.m 1, 2}
# assert_equal %q{[:ok, :ok, :ok, :ok, :ok, :ok, :ng, :ng]}, proc{
# $ans = []
# class Foo
# def m
# end
# end
# c1 = c2 = nil
# lambda{
# $SAFE = 4
# c1 = Class.new{
# def m
# end
# }
# c2 = Class.new(Foo){
# alias mm m
# }
# }.call
# def test
# begin
# yield
# rescue SecurityError
# $ans << :ok
# else
# $ans << :ng
# end
# end
# o1 = c1.new
# o2 = c2.new
# test{o1.m}
# test{o2.mm}
# test{o1.send :m}
# test{o2.send :mm}
# test{o1.public_send :m}
# test{o2.public_send :mm}
# test{o1.method(:m).call}
# test{o2.method(:mm).call}
# $ans
# }
assert_equal 'ok', proc{
class C
def x=(n)
end
def m
self.x = :ok
end
end
C.new.m
}
assert_equal 'ok', proc{
proc{
$SAFE = 1
class C
def m
:ok
end
end
}.call
C.new.m
}, '[ruby-core:11998]'
assert_equal 'ok', proc{
proc{
$SAFE = 2
class C
def m
:ok
end
end
}.call
C.new.m
}, '[ruby-core:11998]'
# assert_equal 'ok', proc{
# proc{
# $SAFE = 3
# class C
# def m
# :ng
# end
# end
# }.call
# begin
# C.new.m
# rescue SecurityError
# :ok
# end
# }, '[ruby-core:11998]'
# assert_equal 'ok', proc{
# class B
# def m() :fail end
# end
# class C < B
# undef m
# begin
# remove_method :m
# rescue NameError
# end
# end
# begin
# C.new.m
# rescue NameError
# :ok
# end
# }, '[ruby-dev:31816], [ruby-dev:31817]'
# assert_normal_exit proc{
# begin
# Process.setrlimit(Process::RLIMIT_STACK, 4_202_496)
# # FreeBSD fails this less than 4M + 8K bytes.
# rescue Exception
# exit
# end
# class C
# attr "a" * (10*1024*1024)
# end
# }, '[ruby-dev:31818]'
assert_equal 'ok', proc{
class Module
def define_method2(name, &block)
define_method(name, &block)
end
end
class C
define_method2(:m) {|x, y| :fail }
end
begin
C.new.m([1,2])
rescue ArgumentError
:ok
end
}
# assert_not_match /method_missing/, proc{
# STDERR.reopen(STDOUT)
# variable_or_mehtod_not_exist
# }
# assert_equal '[false, false, false, false, true, true]', proc{
# class C
# define_method(:foo) {
# block_given?
# }
# end
# C.new.foo {}
# class D
# def foo
# D.module_eval{
# define_method(:m1){
# block_given?
# }
# }
# end
# def bar
# D.module_eval{
# define_method(:m2){
# block_given?
# }
# }
# end
# end
# D.new.foo
# D.new.bar{}
# [C.new.foo, C.new.foo{}, D.new.m1, D.new.m1{}, D.new.m2, D.new.m2{}]
# }, '[ruby-core:14813]'
assert_equal 'ok', proc{
class Foo
define_method(:foo) do |&b|
b.call
end
end
Foo.new.foo do
break :ok
end
}, '[ruby-dev:36028]'
# assert_equal '[1, 2, [3, 4]]', proc{
# def regular(a, b, *c)
# [a, b, c]
# end
# regular(*[], 1, *[], *[2, 3], *[], 4)
# }, '[ruby-core:19413]'
# assert_equal '[1, [:foo, 3, 4, :foo]]', proc{
# def regular(a, *b)
# [a, b]
# end
# a = b = [:foo]
# regular(1, *a, *[3, 4], *b)
# }
# assert_equal '["B", "A"]', proc{
# class A
# def m
# proc{ A }
# end
# end
# class B < A
# define_method(:m) do
# ['B', super()]
# end
# end
# class C < B
# end
# C.new.m
# }
# assert_equal 'ok', proc{
# module Foo
# def foo
# begin
# super
# rescue NoMethodError
# :ok
# end
# end
# module_function :foo
# end
# Foo.foo
# }, '[ruby-dev:37587]'
# assert_equal 'Object#foo', proc{
# class Object
# def self.foo
# "Object.foo"
# end
# def foo
# "Object#foo"
# end
# end
# module Foo
# def foo
# begin
# super
# rescue NoMethodError
# :ok
# end
# end
# module_function :foo
# end
# Foo.foo
# }, '[ruby-dev:37587]'
# assert_normal_exit proc{
# class BasicObject
# remove_method :method_missing
# end
# begin
# "a".lalala!
# rescue NoMethodError => e
# e.message == "undefined method `lalala!' for \"a\":String" ? :ok : :ng
# end
# }, '[ruby-core:22298]'
assert_equal 'ok', proc{
"hello"[0] ||= "H"
"ok"
}
assert_equal 'ok', proc{
"hello"[0, 1] ||= "H"
"ok"
}
# assert_equal 'ok', proc{
# class C
# define_method(:foo) do
# C.class_eval { remove_method(:foo) }
# super()
# end
# end
# begin
# C.new.foo
# rescue NoMethodError
# proc{ ok }
# end
# }
# assert_equal 'ok', proc{
# [0][0, &proc{}] += 21
# 'ok'
# }, '[ruby-core:30534]'
test_end
Reference in New Issue View Git Blame Copy Permalink