471 lines
6.1 KiB
Ruby
471 lines
6.1 KiB
Ruby
assert_equal %q{[1, 2, 3]}, %q{
|
|
def getproc &b
|
|
b
|
|
end
|
|
|
|
def m
|
|
yield
|
|
end
|
|
|
|
m{
|
|
i = 1
|
|
m{
|
|
j = 2
|
|
m{
|
|
k = 3
|
|
getproc{
|
|
[i, j, k]
|
|
}
|
|
}
|
|
}
|
|
}.call
|
|
}
|
|
assert_equal %q{7}, %q{
|
|
def make_proc(&b)
|
|
b
|
|
end
|
|
|
|
def make_closure
|
|
a = 0
|
|
make_proc{
|
|
a+=1
|
|
}
|
|
end
|
|
|
|
cl = make_closure
|
|
cl.call + cl.call * cl.call
|
|
}
|
|
assert_equal %q{ok}, %q{
|
|
class C
|
|
def foo
|
|
:ok
|
|
end
|
|
end
|
|
|
|
def block
|
|
C.method(:new).to_proc
|
|
end
|
|
b = block()
|
|
b.call.foo
|
|
}
|
|
assert_equal %q{[0, 1, :last, 0, 2, :last]}, %q{
|
|
def proc &b
|
|
b
|
|
end
|
|
|
|
pr = []
|
|
proc{|i_b|
|
|
p3 = proc{|j_b|
|
|
pr << proc{|k_b|
|
|
[i_b, j_b, k_b]
|
|
}
|
|
}
|
|
p3.call(1)
|
|
p3.call(2)
|
|
}.call(0)
|
|
|
|
pr[0].call(:last).concat pr[1].call(:last)
|
|
}
|
|
assert_equal %q{12}, %q{
|
|
def iter
|
|
yield
|
|
end
|
|
|
|
def getproc &b
|
|
b
|
|
end
|
|
|
|
iter{
|
|
bvar = 3
|
|
getproc{
|
|
bvar2 = 4
|
|
bvar * bvar2
|
|
}
|
|
}.call
|
|
}
|
|
assert_equal %q{200}, %q{
|
|
def iter
|
|
yield
|
|
end
|
|
|
|
def getproc &b
|
|
b
|
|
end
|
|
|
|
loc1 = 0
|
|
pr1 = iter{
|
|
bl1 = 1
|
|
getproc{
|
|
loc1 += 1
|
|
bl1 += 1
|
|
loc1 + bl1
|
|
}
|
|
}
|
|
|
|
pr2 = iter{
|
|
bl1 = 1
|
|
getproc{
|
|
loc1 += 1
|
|
bl1 += 1
|
|
loc1 + bl1
|
|
}
|
|
}
|
|
|
|
pr1.call; pr2.call
|
|
pr1.call; pr2.call
|
|
pr1.call; pr2.call
|
|
(pr1.call + pr2.call) * loc1
|
|
}
|
|
assert_equal %q{[1, 2]}, %q{
|
|
def proc(&pr)
|
|
pr
|
|
end
|
|
|
|
def m
|
|
a = 1
|
|
m2{
|
|
a
|
|
}
|
|
end
|
|
|
|
def m2
|
|
b = 2
|
|
proc{
|
|
[yield, b]
|
|
}
|
|
end
|
|
|
|
pr = m
|
|
x = ['a', 1,2,3,4,5,6,7,8,9,0,
|
|
1,2,3,4,5,6,7,8,9,0,
|
|
1,2,3,4,5,6,7,8,9,0,
|
|
1,2,3,4,5,6,7,8,9,0,
|
|
1,2,3,4,5,6,7,8,9,0,]
|
|
pr.call
|
|
}
|
|
assert_equal %q{1}, %q{
|
|
def proc(&pr)
|
|
pr
|
|
end
|
|
|
|
def m
|
|
a = 1
|
|
m2{
|
|
a
|
|
}
|
|
end
|
|
|
|
def m2
|
|
b = 2
|
|
proc{
|
|
[yield, b]
|
|
}
|
|
100000.times{|x|
|
|
"#{x}"
|
|
}
|
|
yield
|
|
end
|
|
m
|
|
}
|
|
assert_equal %q{[:C, :C]}, %q{
|
|
Const = :top
|
|
class C
|
|
Const = :C
|
|
$pr = proc{
|
|
(1..2).map{
|
|
Const
|
|
}
|
|
}
|
|
end
|
|
$pr.call
|
|
}
|
|
assert_equal %q{top}, %q{
|
|
Const = :top
|
|
class C
|
|
Const = :C
|
|
end
|
|
pr = proc{
|
|
Const
|
|
}
|
|
C.class_eval %q{
|
|
pr.call
|
|
}
|
|
}
|
|
assert_equal %q{1}, %q{
|
|
def m(&b)
|
|
b
|
|
end
|
|
|
|
m{|e_proctest| e_proctest}.call(1)
|
|
}
|
|
assert_equal %q{12}, %q{
|
|
def m(&b)
|
|
b
|
|
end
|
|
|
|
m{|e_proctest1, e_proctest2|
|
|
a = e_proctest1 * e_proctest2 * 2
|
|
a * 3
|
|
}.call(1, 2)
|
|
}
|
|
assert_equal %q{[[], [1], [1, 2], [1, 2, 3]]}, %q{
|
|
[
|
|
Proc.new{|*args| args}.call(),
|
|
Proc.new{|*args| args}.call(1),
|
|
Proc.new{|*args| args}.call(1, 2),
|
|
Proc.new{|*args| args}.call(1, 2, 3),
|
|
]
|
|
}
|
|
assert_equal %q{[[nil, []], [1, []], [1, [2]], [1, [2, 3]]]}, %q{
|
|
[
|
|
Proc.new{|a, *b| [a, b]}.call(),
|
|
Proc.new{|a, *b| [a, b]}.call(1),
|
|
Proc.new{|a, *b| [a, b]}.call(1, 2),
|
|
Proc.new{|a, *b| [a, b]}.call(1, 2, 3),
|
|
]
|
|
}
|
|
assert_equal %q{1}, %q{
|
|
def m(&b)
|
|
b
|
|
end
|
|
m{1}.call
|
|
}
|
|
assert_equal %q{3}, %q{
|
|
def m(&b)
|
|
b
|
|
end
|
|
|
|
m{
|
|
a = 1
|
|
a + 2
|
|
}.call
|
|
}
|
|
assert_equal %Q{ok\n}, %q{
|
|
class A; def get_block; proc {puts "ok"} end end
|
|
block = A.new.get_block
|
|
GC.start
|
|
block.call
|
|
}, '[ruby-core:14885]'
|
|
|
|
assert_equal 'ok', %q{
|
|
a = lambda {|x, y, &b| b }
|
|
b = a.curry[1]
|
|
if b.call(2){} == nil
|
|
:ng
|
|
else
|
|
:ok
|
|
end
|
|
}, '[ruby-core:15551]'
|
|
|
|
assert_equal 'ok', %q{
|
|
lambda {
|
|
break :ok
|
|
:ng
|
|
}.call
|
|
}, '[ruby-dev:34646]'
|
|
|
|
assert_equal %q{[:bar, :foo]}, %q{
|
|
def foo
|
|
klass = Class.new do
|
|
define_method(:bar) do
|
|
return :bar
|
|
end
|
|
end
|
|
[klass.new.bar, :foo]
|
|
end
|
|
foo
|
|
}, "[ ruby-Bugs-19304 ]"
|
|
|
|
assert_equal 'ok', %q{
|
|
$x = :ok
|
|
def def7(x, y)
|
|
x[y]
|
|
$x = :ng
|
|
end
|
|
def test_def7
|
|
def7(lambda {|x| x.call}, Proc.new {return})
|
|
$x = :ng
|
|
end
|
|
test_def7
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
lambda { a = lambda { return }; $x = :ng; a[]; $x = :ok }.call
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
lambda { a = lambda { break }; $x = :ng; a[]; $x = :ok }.call
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def def8
|
|
$x = :ng
|
|
lambda { a = Proc.new { return }; a[]}.call
|
|
$x = :ok
|
|
end
|
|
def8
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
def def9
|
|
lambda {|a| $x = :ok; a[]; $x = :ng }.call(Proc.new { return })
|
|
$x = :ng
|
|
end
|
|
def9
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def def10
|
|
$x = :ng
|
|
lambda { 1.times { return } }.call
|
|
$x = :ok
|
|
end
|
|
$x = :ok
|
|
def10
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def def11
|
|
yield
|
|
end
|
|
begin
|
|
lambda { def11 { return } }.call
|
|
rescue LocalJumpError
|
|
:ng
|
|
else
|
|
:ok
|
|
end
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def def12
|
|
b = Proc.new { $x = :ng; lambda { return }.call; $x = :ok }.call
|
|
end
|
|
def12
|
|
$x
|
|
}, '[ruby-core:17164]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def m
|
|
pr = proc{
|
|
proc{
|
|
return :ok
|
|
}
|
|
}.call
|
|
pr.call
|
|
:ng
|
|
end
|
|
m()
|
|
}
|
|
|
|
assert_equal 'ok', %q{
|
|
class Foo
|
|
def call_it(&block)
|
|
p = Proc.new(&block)
|
|
p.call
|
|
end
|
|
end
|
|
|
|
def give_it
|
|
proc { :ok }
|
|
end
|
|
|
|
f = Foo.new
|
|
a_proc = give_it
|
|
f.call_it(&give_it())
|
|
}, '[ruby-core:15711]'
|
|
|
|
assert_equal 'foo!', %q{
|
|
class FooProc < Proc
|
|
def initialize
|
|
@foo = "foo!"
|
|
end
|
|
|
|
def bar
|
|
@foo
|
|
end
|
|
end
|
|
|
|
def bar
|
|
FooProc.new &lambda{
|
|
p 1
|
|
}
|
|
end
|
|
|
|
fp = bar(&lambda{
|
|
p 2
|
|
})
|
|
|
|
fp.bar
|
|
}, 'Subclass of Proc'
|
|
|
|
assert_equal 'ok', %q{
|
|
o = Object.new
|
|
def o.write(s); end
|
|
$stderr = o
|
|
at_exit{
|
|
print $!.message
|
|
}
|
|
raise "ok"
|
|
}
|
|
|
|
assert_equal 'ok', %q{
|
|
lambda do
|
|
class A
|
|
class B
|
|
proc{return :ng}.call
|
|
end
|
|
end
|
|
end.call
|
|
:ok
|
|
}
|
|
|
|
assert_equal 'ok', %q{
|
|
$proc = proc{return}
|
|
begin
|
|
lambda do
|
|
class A
|
|
class B
|
|
$proc.call
|
|
end
|
|
end
|
|
end.call
|
|
:ng
|
|
rescue LocalJumpError
|
|
:ok
|
|
end
|
|
}
|
|
|
|
assert_equal 'ok', %q{
|
|
def x
|
|
binding
|
|
end
|
|
b = x{|a| a }
|
|
b.eval('yield("ok")')
|
|
}, '[Bug #5634]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def x
|
|
binding
|
|
end
|
|
eval("x { 'ok' }").eval "yield"
|
|
}, '[Bug #5634]'
|
|
|
|
assert_equal 'ok', %q{
|
|
def x
|
|
binding
|
|
end
|
|
def m
|
|
x{ 'ok' }
|
|
end
|
|
eval('yield', m)
|
|
}, '[Bug #5634]'
|
|
|