1berry/ruby
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

* yarvtest/test_method.rb: removed (merged to bootstraptest).

Browse Source 
* yarvtest/test_class.rb: ditto.


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@11867 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
aamine 2007-02-24 09:56:02 +00:00
parent b1b44331de
commit e9ee00eead
3 changed files with 6 additions and 1399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ChangeLog
View File

@ -1,3 +1,9 @@
Sat Feb 24 18:55:50 2007 Minero Aoki <aamine@loveruby.net>
* yarvtest/test_method.rb: removed (merged to bootstraptest).
* yarvtest/test_class.rb: ditto.
Sat Feb 24 18:44:39 2007 Minero Aoki <aamine@loveruby.net> Sat Feb 24 18:44:39 2007 Minero Aoki <aamine@loveruby.net>
* bootstraptest/test_class.rb: new file. * bootstraptest/test_class.rb: new file.

793
yarvtest/test_class.rb
View File

@ -1,793 +0,0 @@
require 'yarvtest/yarvtest'
class TestClass < YarvTestBase
def test_simple
ae %q(
class C
def m(a,b)
a+b
end
end
C.new.m(1,2)
) do
remove_const(:C)
end
ae %q(
class A
end
class A::B
def m
A::B.name
end
end
A::B.new.m
) do
remove_const(:A)
end
#ae %q(
# class (class C;self; end)::D < C
# self.name
# end
#) do
# remove_const(:C)
#end
end
def test_sub
ae %q(
class A
def m
123
end
end
class B < A
end
B.new.m
) do
remove_const(:A)
remove_const(:B)
end
ae %q(
class A
class B
class C
def m
456
end
end
end
end
class A::BB < A::B::C
end
A::BB.new.m
) do
remove_const(:A)
end
end
def test_attr
ae %q(
class C
def set
@a = 1
end
def get
@a
end
end
c = C.new
c.set
c.get
) do
remove_const(:C)
end
end
def test_initialize
ae %q{
class C
def initialize
@a = :C
end
def a
@a
end
end
C.new.a
} do
remove_const(:C)
end
end
def test_to_s
ae %q{
class C
def to_s
"hoge"
end
end
"ab#{C.new}cd"
} do
remove_const(:C)
end
end
def test_attr_accessor
ae %q{
class C
attr_accessor :a
attr_reader :b
attr_writer :c
def b_write
@b = 'huga'
end
def m a
'test_attr_accessor' + @b + @c
end
end
c = C.new
c.a = true
c.c = 'hoge'
c.b_write
c.m(c.b)
} do
remove_const(:C)
end
end
def test_super
ae %q{
class C
def m1
100
end
def m2 a
a + 100
end
end
class CC < C
def m1
super() * 100
end
def m2
super(200) * 100
end
end
a = CC.new
a.m1 + a.m2
} do
remove_const(:C)
remove_const(:CC)
end
end
def test_super2
ae %q{
class C
def m(a, b)
a+b
end
end
class D < C
def m arg
super(*arg) + super(1, arg.shift)
end
end
D.new.m([1, 2])
}
ae %q{
class C
def m
yield
end
end
class D < C
def m
super(){
:D
}
end
end
D.new.m{
:top
}
}
ae %q{
class C0
def m a, &b
[a, b]
end
end
class C1 < C0
def m a, &b
super a, &b
end
end
C1.new.m(10)
}
end
def test_zsuper_from_define_method
ae %q{
class C
def a
"C#a"
end
def m
"C#m"
end
end
class D < C
define_method(:m){
super
}
define_method(:a){
r = nil
1.times{
r = super
}
r
}
end
D.new.m + D.new.a
}
ae %q{
class X
def a
"X#a"
end
def b
class << self
define_method(:a) {
super
}
end
end
end
x = X.new
x.b
x.a
}
ae %q{
class C
def m arg
"C#m(#{arg})"
end
def b
class << self
define_method(:m){|a|
super
}
end
self
end
end
C.new.b.m(:ok)
}
ae %q{
class C
def m *args
"C#m(#{args.join(', ')})"
end
def b
class << self
define_method(:m){|a, b|
r = nil
1.times{
r = super
}
r
}
end
self
end
end
C.new.b.m(:ok1, :ok2)
} if false # ruby 1.9 dumped core
ae %q{ # [yarv-dev:859]
$ans = []
class A
def m_a
$ans << "m_a"
end
def def_m_a
$ans << "def_m_a"
end
end
class B < A
def def_m_a
B.class_eval{
super
define_method(:m_a) do
super
end
}
super
end
end
b = B.new
b.def_m_a
b.m_a
$ans
}
ae %q{
class A
def hoge
:hoge
end
def foo
:foo
end
end
class B < A
def memoize(name)
B.instance_eval do
define_method(name) do
[name, super]
end
end
end
end
b = B.new
b.memoize(:hoge)
b.memoize(:foo)
[b.foo, b.hoge]
}
end
def test_zsuper
ae %q{
class C
def m1
100
end
def m2 a
a + 100
end
def m3 a
a + 200
end
end
class CC < C
def m1
super * 100
end
def m2 a
super * 100
end
def m3 a
a = 400
super * 100
end
end
a = CC.new
a.m1 + a.m2(200) + a.m3(300)
} do
remove_const(:C)
remove_const(:CC)
end
end
def test_zsuper2
ae %q{
class C1
def m
10
end
end
class C2 < C1
def m
20 + super
end
end
class C3 < C2
def m
30 + super
end
end
C3.new.m
} do
remove_const(:C1)
remove_const(:C2)
remove_const(:C3)
end
ae %q{
class C
def m
yield
end
end
class D < C
def m
super{
:D
}
end
end
D.new.m{
:top
}
}
ae %q{
class C
def m(a, b, c, d)
a+b+c+d
end
end
class D < C
def m(a, b=1, c=2, *d)
d[0] ||= 0.1
[super,
begin
a *= 2
b *= 3
c *= 4
d[0] *= 5
super
end
]
end
end
ary = []
ary << D.new.m(10, 20, 30, 40)
if false # On current ruby, these programs don't work
ary << D.new.m(10, 20, 30)
ary << D.new.m(10, 20)
ary << D.new.m(10)
end
ary
}
ae %q{
class C
def m(a, b, c, d)
a+b+c+d
end
end
class D < C
def m(a, b=1, c=2, d=3)
[super,
begin
a *= 2
b *= 3
c *= 4
d *= 5
super
end
]
end
end
ary = []
ary << D.new.m(10, 20, 30, 40)
ary << D.new.m(10, 20, 30)
ary << D.new.m(10, 20)
ary << D.new.m(10)
ary
}
ae %q{
class C
def m(a, b, c, d, &e)
a+b+c+d+e.call
end
def n(a, b, c, d, &e)
a+b+c+d+e.call
end
end
class D < C
def m(a, b=1, c=2, *d, &e)
super
end
def n(a, b=1, c=2, d=3, &e)
super
end
end
ary = []
ary << D.new.m(1, 2, 3, 4){
5
}
ary << D.new.m(1, 2, 3, 4, &lambda{
5
})
ary << D.new.n(1, 2, 3){
5
}
ary << D.new.n(1, 2){
5
}
ary << D.new.n(1){
5
}
ary
}
end
def test_super_with_private
ae %q{
class C
private
def m1
:OK
end
protected
def m2
end
end
class D < C
def m1
[super, super()]
end
def m2
[super, super()]
end
end
D.new.m1 + D.new.m2
}
end
def test_const_in_other_scope
ae %q{
class C
Const = :ok
def m
1.times{
Const
}
end
end
C.new.m
} do
remove_const(:C)
end
ae %q{
class C
Const = 1
def m
begin
raise
rescue
Const
end
end
end
C.new.m
} do
remove_const(:C)
end
end
def test_reopen_not_class
ae %q{ # [yarv-dev:782]
begin
B = 1
class B
p B
end
rescue TypeError => e
e.message
end
}
ae %q{ # [yarv-dev:800]
begin
B = 1
module B
p B
end
rescue TypeError => e
e.message
end
}
end
def test_set_const_not_class
ae %q{
begin
1::A = 1
rescue TypeError => e
e.message
end
}
end
def test_singletonclass
ae %q{
obj = ''
class << obj
def m
:OK
end
end
obj.m
}
ae %q{
obj = ''
Const = :NG
class << obj
Const = :OK
def m
Const
end
end
obj.m
}
ae %q{
obj = ''
class C
def m
:NG
end
end
class << obj
class C
def m
:OK
end
end
def m
C.new.m
end
end
obj.m
}
ae %q{ # [yarv-dev:818]
class A
end
class << A
C = "OK"
def m
class << Object
$a = C
end
end
end
A.m
$a
}
end
def test_include
ae %q{
module M
class A
def hoge
"hoge"
end
end
end
class A
include M
def m
[Module.nesting, A.new.hoge, instance_eval("A.new.hoge")]
end
end
A.new.m
}
end
def test_colon3
ae %q{
class A
::B = :OK
end
B
}
ae %q{
class A
class ::C
end
end
C
}
end
def test_undef
# [yarv-dev:999]
ae %q{
class Parent
def foo
end
end
class Child < Parent
def bar
end
undef foo, bar
end
c = Child.new
[c.methods.include?('foo'), c.methods.include?('bar')]
}
end
def test_dup
ae %q{
ObjectSpace.each_object{|obj|
if Module === obj && (obj.respond_to? :dup)
obj.dup
end
}
:ok
}
end
def test_ivar2
ae %q{
class C
def initialize
@_v = 1
end
def foo
@_v
end
end
class D < C
def initialize
@_v = 2
super
end
def foo
[@_v, super]
end
end
D.new.foo
}
ae %q{
class C
def initialize
@_c = 1
end
end
class D < C
def initialize
super
@_d = 2
end
end
D.new.instance_variables
}
end
end

606
yarvtest/test_method.rb
View File

@ -1,606 +0,0 @@
require 'yarvtest/yarvtest'
class TestMethod < YarvTestBase
def test_simple_method
ae %q{
def m_simple_method
1
end
m_simple_method()
}
end
def test_polymorphic
ae %q{
o1 = 'str'
o2 = 1
str = ''
i = 1
while i<10
i+=1
o = (i%2==0) ? o1 : o2
str += o.to_s
end
str
}
end
def test_arg
ae <<-'EOS'
def m_arg(a1, a2)
a1+a2
end
m_arg(1,2)
EOS
end
def test_rec
ae <<-'EOS'
def m_rec n
if n > 1
n + m_rec(n-1)
else
1
end
end
m_rec(10)
EOS
end
def test_splat
ae %q{
def m a
a
end
begin
m(*1)
rescue TypeError
:ok
end
}
ae %q{
def m a, b
[a, b]
end
m(*[1,2])
}
ae %q{
def m a, b, c
[a, b, c]
end
m(1, *[2, 3])
}
ae %q{
def m a, b, c
[a, b, c]
end
m(1, 2, *[3])
}
end
def test_rest
ae %q{
def m *a
a
end
m
}
ae %q{
def m *a
a
end
m 1
}
ae %q{
def m *a
a
end
m 1, 2, 3
}
ae %q{
def m x, *a
[x, a]
end
m 1
}
ae %q{
def m x, *a
[x, a]
end
m 1, 2
}
ae %q{
def m x, *a
[x, a]
end
m 1, 2, 3, 4
}
end
def test_opt
ae %q{
def m a=1
a
end
m
}
ae %q{
def m a=1
a
end
m 2
}
ae %q{
def m a=1, b=2
[a, b]
end
m
}
ae %q{
def m a=1, b=2
[a, b]
end
m 10
}
ae %q{
def m a=1, b=2
[a, b]
end
m 10, 20
}
ae %q{
def m x, a=1, b=2
[x, a, b]
end
m 10
}
ae %q{
def m x, a=1, b=2
[x, a, b]
end
m 10, 20
}
ae %q{
def m x, a=1, b=2
[x, a, b]
end
m 10, 20, 30
}
ae %q{
def m x, y, a
[x, y, a]
end
m 10, 20, 30
}
end
def test_opt_rest
ae %q{
def m0 b = 0, c = 1, *d
[:sep, b, c, d]
end
def m1 a, b = 0, c = 1, *d
[:sep, a, b, c, d]
end
def m2 x, a, b = 0, c = 1, *d
[:sep, x, a, b, c, d]
end
def m3 x, y, a, b = 0, c = 1, *d
[:sep, x, y, a, b, c, d]
end
def s3 x, y, a, b = 0, c = 1
[:sep, x, y, a, b, c]
end
m0() +
m0(:a) +
m0(:a, :b) +
m0(:a, :b, :c) +
m0(:a, :b, :c, :d) +
m0(:a, :b, :c, :d, :e) +
m1(:a) +
m1(:a, :b) +
m1(:a, :b, :c) +
m1(:a, :b, :c, :d) +
m1(:a, :b, :c, :d, :e) +
m2(:a, :b) +
m2(:a, :b, :c) +
m2(:a, :b, :c, :d) +
m2(:a, :b, :c, :d, :e) +
m2(:a, :b, :c, :d, :e, :f) +
m3(:a, :b, :c) +
m3(:a, :b, :c, :d) +
m3(:a, :b, :c, :d, :e) +
m3(:a, :b, :c, :d, :e, :f) +
m3(:a, :b, :c, :d, :e, :f, :g)
}
end
def test_opt_rest_block
ae %q{
def m a, b = 0, c = 1, *d, &pr
[a, b, c, d, pr]
end
m(:a) +
m(:a, :b) +
m(:a, :b, :c) +
m(:a, :b, :c, :d) +
m(:a, :b, :c, :d, :e)
}
ae %q{
def m a, b = 0, c = 1, *d, &pr
[a, b, c, d, pr.call]
end
m(:a){1} +
m(:a, :b){2} +
m(:a, :b, :c){3} +
m(:a, :b, :c, :d){4} +
m(:a, :b, :c, :d, :e){5}
}
end
def test_singletonmethod
ae %q{
lobj = Object.new
def lobj.m
:singleton
end
lobj.m
}
ae %q{
class C
def m
:C_m
end
end
lobj = C.new
def lobj.m
:Singleton_m
end
lobj.m
}
end
def test_singletonmethod_with_const
ae %q{
class C
Const = :C
def self.m
1.times{
Const
}
end
end
C.m
}
end
def test_alias
ae %q{
def m1
:ok
end
alias :m2 :m1
m1
}
ae %q{
def m1
:ok
end
alias m2 m1
m1
}
ae %q{
def m1
:ok
end
alias m2 :m1
m1
}
ae %q{
def m1
:ok
end
alias :m2 m1
m1
}
ae %q{
def m1
:ok
end
alias m2 m1
def m1
:ok2
end
[m1, m2]
}
end
def test_split
ae %q{
'abc'.split(/b/)
}
ae %q{
1.times{|bi|
'abc'.split(/b/)
}
}
end
def test_block_pass
ae %q{
def getproc &b
b
end
def m
yield
end
m(&getproc{
"test"
})
}
ae %q{
def getproc &b
b
end
def m a
yield a
end
m(123, &getproc{|block_a|
block_a
})
}
ae %q{
def getproc &b
b
end
def m *a
yield a
end
m(123, 456, &getproc{|block_a|
block_a
})
}
ae %q{
def getproc &b
b
end
[1,2,3].map(&getproc{|block_e| block_e*block_e})
}
ae %q{
def m a, b, &c
c.call(a, b)
end
m(10, 20){|x, y|
[x+y, x*y]
}
}
ae %q{
def m &b
b
end
m(&nil)
}
ae %q{
def m a, &b
[a, b]
end
m(1, &nil)
}
ae %q{
def m a
[a, block_given?]
end
m(1, &nil)
}
end
def test_method_missing
ae %q{
class C
def method_missing id
id
end
end
C.new.hoge
} do
remove_const :C
end
ae %q{
class C
def method_missing *args, &b
b.call(args)
end
end
C.new.foo(1){|args|
args
}
C.new.foo(1){|args|
args
} +
C.new.foo(1, 2){|args|
args
}
}
end
def test_svar
ae %q{
'abc'.match(/a(b)c/)
$1
}
end
def test_nested_method
ae %q{
class A
def m
def m2
p :m2
end
m2()
end
end
A.new.m
}
ae %q{
class A
def m
def m2
p :m2
end
m2()
end
end
instance_eval('A.new.m')
}
end
def test_private_class_method
ae %q{
class C
def self.m
:ok
end
def self.test
m
end
private_class_method :m
end
C.test
}
end
def test_alias_and_private
ae %q{ # [yarv-dev:899]
$ans = []
class C
def m
$ans << "OK"
end
end
C.new.m
class C
alias mm m
private :mm
end
C.new.m
begin
C.new.mm
rescue NoMethodError
$ans << "OK!"
end
$ans
}
end
def test_break_from_defined_method
ae %q{
class C
define_method(:foo){
break :ok
}
end
C.new.foo
}
end
def test_return_from_defined_method
ae %q{
class C
define_method(:m){
return :ok
}
end
C.new.m
}
end
def test_send
ae %q{
$r = []
class C
def m *args
$r << "C#m #{args.inspect} #{block_given?}"
end
end
obj = C.new
obj.send :m
obj.send :m, :x
obj.send :m, :x, :y
obj.send(:m){}
obj.send(:m, :x){}
$r
}
ae %q{
class C
def send
:ok
end
end
C.new.send
}
end
def test_send_with_private
ae %q{
begin
def m
end
self.send :m
rescue NoMethodError
:ok
else
:ng
end
}
ae %q{
begin
def m
end
send :m
rescue NoMethodError
:ng
else
:ok
end
}
end
def test_funcall
ae %q{
$r = []
def m *args
$r << "m() #{args.inspect} #{block_given?}"
end
funcall :m
funcall :m, :x
funcall :m, :x, :y
funcall(:m){}
funcall(:m, :x){}
}
end
end