130 lines
3.4 KiB
Ruby
Vendored
130 lines
3.4 KiB
Ruby
Vendored
##
|
|
# Proc(Ext) Test
|
|
|
|
def enable_debug_info?
|
|
return @enable_debug_info unless @enable_debug_info == nil
|
|
begin
|
|
raise
|
|
rescue => e
|
|
@enable_debug_info = !e.backtrace.empty?
|
|
if @enable_debug_info && e.backtrace[0].include?("(unknown)")
|
|
@enable_debug_info = false
|
|
end
|
|
return @enable_debug_info
|
|
end
|
|
end
|
|
|
|
assert('Proc#source_location') do
|
|
skip unless enable_debug_info?
|
|
file, line = Proc.new{}.source_location
|
|
assert_equal __FILE__, file
|
|
assert_equal __LINE__ - 2, line
|
|
end
|
|
|
|
assert('Proc#inspect') do
|
|
ins = Proc.new{}.inspect
|
|
if enable_debug_info?
|
|
metas = %w(\\ * ? [ ] { })
|
|
file = __FILE__.split("").map{|c| metas.include?(c) ? "\\#{c}" : c}.join
|
|
line = __LINE__ - 4
|
|
else
|
|
file = line = "-"
|
|
end
|
|
assert_match "#<Proc:0x* #{file}:#{line}>", ins
|
|
end
|
|
|
|
assert('Proc#lambda?') do
|
|
assert_true lambda{}.lambda?
|
|
assert_true !Proc.new{}.lambda?
|
|
end
|
|
|
|
assert('Proc#===') do
|
|
proc = Proc.new {|a| a * 2}
|
|
assert_equal 20, (proc === 10)
|
|
end
|
|
|
|
assert('Proc#yield') do
|
|
proc = Proc.new {|a| a * 2}
|
|
assert_equal 20, proc.yield(10)
|
|
end
|
|
|
|
assert('Proc#curry') do
|
|
b = proc {|x, y, z| (x||0) + (y||0) + (z||0) }
|
|
assert_equal 6, b.curry[1][2][3]
|
|
assert_equal 6, b.curry[1, 2][3, 4]
|
|
assert_equal 6, b.curry(5)[1][2][3][4][5]
|
|
assert_equal 6, b.curry(5)[1, 2][3, 4][5]
|
|
assert_equal 1, b.curry(1)[1]
|
|
|
|
b = lambda {|x, y, z| (x||0) + (y||0) + (z||0) }
|
|
assert_equal 6, b.curry[1][2][3]
|
|
assert_raise(ArgumentError) { b.curry[1, 2][3, 4] }
|
|
assert_raise(ArgumentError) { b.curry(5) }
|
|
assert_raise(ArgumentError) { b.curry(1) }
|
|
|
|
assert_false(proc{}.curry.lambda?)
|
|
assert_true(lambda{}.curry.lambda?)
|
|
end
|
|
|
|
assert('Proc#parameters') do
|
|
assert_equal([], Proc.new {}.parameters)
|
|
assert_equal([], Proc.new {||}.parameters)
|
|
assert_equal([[:opt, :a]], Proc.new {|a|}.parameters)
|
|
assert_equal([[:req, :a]], lambda {|a|}.parameters)
|
|
assert_equal([[:opt, :a]], lambda {|a=nil|}.parameters)
|
|
assert_equal([[:req, :a]], ->(a){}.parameters)
|
|
assert_equal([[:rest, :*]], lambda { |*| }.parameters)
|
|
assert_equal([[:rest, :a]], Proc.new {|*a|}.parameters)
|
|
assert_equal([[:opt, :x], [:opt, :y], [:rest, :other]], Proc.new{|x,y=42,*other|}.parameters)
|
|
assert_equal([[:opt, :a], [:opt, :b], [:opt, :c], [:opt, :d], [:rest, :e], [:opt, :f], [:opt, :g], [:block, :h]], Proc.new {|a,b,c=:c,d=:d,*e,f,g,&h|}.parameters)
|
|
assert_equal([[:req, :a], [:req, :b], [:opt, :c], [:opt, :d], [:rest, :e], [:req, :f], [:req, :g], [:block, :h]], lambda {|a,b,c=:c,d=:d,*e,f,g,&h|}.parameters)
|
|
end
|
|
|
|
assert('Proc#to_proc') do
|
|
proc = Proc.new {}
|
|
assert_equal proc, proc.to_proc
|
|
end
|
|
|
|
assert('Kernel#proc') do
|
|
assert_true !proc{|a|}.lambda?
|
|
|
|
assert_raise LocalJumpError do
|
|
proc{ break }.call
|
|
end
|
|
end
|
|
|
|
assert "Proc#<< and Proc#>>" do
|
|
add3 = ->(n) { n + 3 }
|
|
mul2 = ->(n) { n * 2 }
|
|
|
|
f1 = mul2 << add3
|
|
assert_kind_of Proc, f1
|
|
assert_equal 16, f1.call(5)
|
|
|
|
f2 = mul2 >> add3
|
|
assert_kind_of Proc, f2
|
|
assert_equal 13, f2.call(5)
|
|
end
|
|
|
|
assert('mrb_proc_new_cfunc_with_env') do
|
|
ProcExtTest.mrb_proc_new_cfunc_with_env(:test)
|
|
ProcExtTest.mrb_proc_new_cfunc_with_env(:mruby)
|
|
|
|
t = ProcExtTest.new
|
|
|
|
assert_equal :test, t.test
|
|
assert_equal :mruby, t.mruby
|
|
end
|
|
|
|
assert('mrb_cfunc_env_get') do
|
|
ProcExtTest.mrb_cfunc_env_get :get_int, [0, 1, 2]
|
|
|
|
t = ProcExtTest.new
|
|
|
|
assert_raise(TypeError) { t.cfunc_without_env }
|
|
|
|
assert_raise(IndexError) { t.get_int(-1) }
|
|
assert_raise(IndexError) { t.get_int(3) }
|
|
|
|
assert_equal 1, t.get_int(1)
|
|
end
|