Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

749 lines (667 sloc) 12.075 kB
assert ":ok", "1.times { p :ok }"
assert "42", "p 42.times {}"
assert "42", "i = 0; 42.times { i += 1 }; p i"
assert "42", "x = nil; 43.times { |i| x = i }; p x"
assert "", "0.times { p :nok }"
assert ":ok", "def foo; yield; end; foo { p :ok }"
assert "42", "def foo; yield 42; end; foo { |x| p x }"
assert "", "def foo; end; foo { p :nok }"
assert ":ok", "def foo; yield; end; send(:foo) { p :ok }"
assert ":ok", "def foo; yield; end; send(:foo, &proc { p :ok })"
assert ":ok", %{
class X; def initialize; yield ;end; end
X.new { p :ok }
}
assert ":ok", %{
def foo; raise; end
def bar; p :ok unless block_given?; end
begin
foo { p :nok }
rescue
bar
end
}
assert ":ok", %{
def foo; yield; end
begin
foo { raise }
rescue
1.times { p :ok }
end
}
assert ":ok", "def foo(&b); b.call; end; foo { p :ok }"
assert "42", "def foo(&b); b.call(42); end; foo { |x| p x }"
assert ":ok", "def foo(&b); p :ok if b.nil?; end; foo"
assert ":ok", %{
class X; def initialize(&b); b.call ;end; end
X.new { p :ok }
}
assert "42", %q{
def foo; yield 20, 1, 20, 1; end
foo do |a, b, c, d|
x = a + b + c + d
p x
end
}
assert ":ok", %q{
def foo; yield; end
foo do |x, y, z|
p :ok if x == nil and y == nil and z == nil
end
}
assert ":ok", %q{
def foo; yield(1, 2); end
foo do |x, y, z|
p :ok if x == 1 and y == 2 and z == nil
end
}
assert ":ok", %q{
def foo; yield(1, 2); end
foo do |x|
p :ok if x == 1
end
}
assert ":ok", %q{
def foo; yield(1, 2); end
foo do |x, y = :y, z|
p :ok if x == 1 and y == :y and z == 2
end
}
assert ":ok", %q{
def foo; yield(1); end
foo do |x, y = :y, z|
p :ok if x == 1 and y == :y and z == nil
end
}
assert ":ok", %q{
def foo; yield(1, 2, 3, 4); end
foo do |x, y = :y, *rest, z|
p :ok if x == 1 and y == 2 and rest == [3] and z == 4
end
}
assert ":ok", %q{
def foo; yield([1, 2]); end
foo do |x, y = :y, z|
p :ok if x == 1 and y == :y and z == 2
end
}
assert "[1, 2]", %q{
def foo; yield(1, 2); end
foo { |*rest| p rest }
}
assert "[[1, 2]]", %q{
def foo; yield([1, 2]); end
foo { |*rest| p rest }
}
assert "[1, [2]]", %q{
def foo; yield([1, 2]); end
foo { |a, *rest| p [a, rest] }
}
assert "[[1, 2], []]", %q{
def foo; yield([1, 2]); end
foo { |a = 42, *rest| p [a, rest] }
}
assert "[1, 2, []]", %q{
def foo; yield([1, 2]); end
foo { |a = 42, *rest, b| p [a, b, rest] }
}
assert "[1, 2, []]", %q{
def foo; yield([1, 2]); end
foo { |a, b = 42, *rest| p [a, b, rest] }
}
assert "[[1, 2], 42, []]", %q{
def foo; yield([1, 2]); end
foo { |a = 42, b = 42, *rest| p [a, b, rest] }
}
assert "[[1, 2], []]", %q{
def foo; yield([1, 2]); end
foo { |a = 42, *rest| p [a, rest] }
}
assert 'nil', 'p = proc { |x,| p x }; p.call'
assert '42', 'p = proc { |x,| p x }; p.call(42)'
assert '42', 'p = proc { |x,| p x }; p.call(42,1,2,3)'
assert '42', 'p = proc { |x,| p x }; p.call([42])'
assert '42', 'p = proc { |x,| p x }; p.call([42,1,2,3])'
assert "true", "def foo; p block_given?; end; foo {}"
assert "false", "def foo; p block_given?; end; foo"
assert "false", "def foo; p block_given?; end; def bar; foo; end; bar {}"
assert ':ok', "def foo; yield; end; begin; foo; rescue LocalJumpError; p :ok; end"
assert ":ok", "def foo(&m); m.call; end; foo { p :ok }"
assert ":ok", "def foo(&m); p :ok if m == nil; end; foo"
assert "[[1, 0, 1, 0, 1], [0, 1, 1, 0, 0], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0]]", %q{
def trans(xs)
(0..xs[0].size - 1).collect do |i|
xs.collect{ |x| x[i] }
end
end
p trans([1,2,3,4,5])
}, :archs => ['i386']
assert "[[1, 0, 1, 0, 1], [0, 1, 1, 0, 0], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]", %q{
def trans(xs)
(0..xs[0].size - 1).collect do |i|
xs.collect{ |x| x[i] }
end
end
p trans([1,2,3,4,5])
}, :archs => ['x86_64']
assert '45', "p (5..10).inject {|sum, n| sum + n }"
assert '151200', "p (5..10).inject(1) {|product, n| product * n }"
assert "42", "def foo(x); yield x; end; p = proc { |x| p x }; foo(42, &p)"
assert "42", %q{
class X
def to_proc; proc { |x| p x }; end
end
def foo(x); yield x; end
foo(42, &X.new)
}
assert "42", "def foo; yield; end; begin; foo(&Object.new); rescue TypeError; p 42; end"
assert "42", "x = 0; proc { x = 42 }.call; p x"
assert "42", "x = 0; p = proc { x += 40 }; x = 2; p.call; p x"
assert "42", "n = 0; 100.times { |i| n += 1; break if n == 42 }; p n"
assert "42", "n = 0; 100.times { |i| next if i % 2 == 0; n += 1; }; p n - 8"
assert "42", "p 100.times { break 42 }"
assert "42", "p proc { next 42 }.call"
assert "42", "i=0; while i<1; begin; i=2; next; ensure; p 42; end; end"
assert "42", "begin p proc { break 24 }.call rescue LocalJumpError; p 42 end", :known_bug => true
assert "42", "def foo; yield; end; foo { break }; 1.times {p 42}"
assert "42", "1.times { begin; break; ensure; p 42; end }"
assert "42", "i=0; while i<1; begin; break; ensure; p 42; end; end"
assert "42\n42", "i=0; while true; begin; break if i>0; i=1; redo; ensure; p 42; end; end"
assert "42", "p [42].map { |x| x }.map { |y| y }[0]"
assert '1302', %q{
$count = 0
def foo(v, x)
x.times {
x -= 1
foo(v, x)
$count += v
}
end
foo(42, 5)
p $count
}
assert '42', "x=42; 1.times { 1.times { 1.times { p x } } }"
assert '42', "def f; 1.times { yield 42 }; end; f {|x| p x}"
assert '42', "def foo; x = 42; proc { x }; end; p foo.call"
assert '42', %q{
def foo() x=1; [proc { x }, proc {|z| x = z}]; end
a, b = foo
b.call(42)
p a.call
}
assert "2\n1", %{
def f(x, y)
1.times {
f(2, false) if y
p x
}
end
f(1, true)
}
assert "42", %{
def f()
a = nil
1.times do
x = 42
a = proc { x }
end
a
end
p f.call
}
assert "42", %{
def f()
x = 42
a = nil
1.times do
a = proc { x }
end
a
end
p f.call
}
assert "42", %{
def f()
x = 40
a = nil
1.times do
1.times do
y = 2
a = proc { x + y }
end
end
a
end
p f.call
}
assert "42", %{
def f()
a = nil
b = proc do
x = 42
a = proc { x }
end
b.call
end
p f.call
}
assert "42", %{
def f()
x = 42
a = nil
b = proc do
a = proc { x }
end
b.call
end
p f.call
}
assert "42", %{
def f()
a = nil
b = false
x = 42
while true
return a if b
b = true
a = proc { x }
end
end
p f.call
}
assert "42", %{
def f()
x = 42
$a = proc { x }
raise 'w'
end
begin
f
rescue
p $a.call
end
}
assert "42", %{
def g()
raise 'w'
end
def f()
x = 42
$a = proc { x }
g
end
begin
f
rescue
p $a.call
end
}
assert "42", %{
def f()
x = 42
$a = proc { x }
throw :w
end
catch(:w) do
f
end
p $a.call
}
assert "42", %{
def g()
throw :w
end
def f()
x = 42
$a = proc { x }
g()
end
catch(:w) do
f
end
p $a.call
}
assert "42", %{
def f()
x = 42
a = proc { x }
1.times { return a }
end
p f.call
}
assert ":ok", %{
def f()
2.times do
begin
yield
rescue
end
end
end
f { raise 'a' }
p :ok
}
assert ":ok", %{
def f()
2.times do
catch(:a) do
yield
end
end
end
f { throw :a }
p :ok
}
assert ':ok', %{
def f()
a = :ok
b = true
x = proc { a }
1.times {
return x
}
end
p f.call
}
assert ':ok', %{
def f()
a = :ok
b = false
while true
return x = proc { a } if b
b = true
end
end
p f.call
}
assert ':ok', %{
$a = []
def foo(what, &block)
$a << block
end
[:ok].each do |type|
foo type do
p type
end
end
$a.each do |b| b.call end
}
# Enumerator
assert "[\"f\", \"o\", \"o\"]", "p 'foo'.chars.to_a"
assert ':ok', %{
def foo(x); p :ok if block_given?; end
def bar; p :nok if block_given?; end
foo(bar) {}
}
assert ':ok', %{
def foo(x=bar); p :ok if block_given?; end
def bar; p :nok if block_given?; end
foo {}
}
assert ':ok', %{
class X
def foo; p :nok if block_given?; self; end
def bar; p :ok if block_given?; self; end
end
X.new.foo.bar {}
}
assert ':ok', %{
def foo; Proc.new; end; foo { p :ok }.call
}
assert ':ok', %{
def foo(x=Proc.new); x.call; end; foo { p :ok }
}
assert ':ok', %{
class X
def initialize(x=Proc.new); x.call; end
end
X.new { p :ok }
}
assert '3', %{
def foo(a=Proc.new, b=Proc.new, c=Proc.new)
a.call; b.call; c.call
end
i = 0
foo { i+=1 }
p i
}
assert ':ok', %{
def foo(x=Proc.new); x.call; end
def bar; foo; end
begin
bar { p :nok }
rescue ArgumentError
p :ok
end
}
assert ':ok', %{
def a
yield
end
def b(&block)
a(&block)
end
def c
b do
yield
end
end
c { p :ok }
}
assert ':ok', %{
def a
1.times do yield end
end
def b(&block)
a(&block)
end
def c
b do
yield
end
end
c { p :ok }
}
assert '42', %{
def foo; 1.times { return 42 }; p :nok; end
p foo
}
assert '42', %{
def foo; 1.times { 1.times { 1.times { return 42 } } }; p :nok; end
p foo
}
assert '42', %{
def foo; 1.times { return yield }; end
def bar; foo { return 42 }; p :nok; end
p bar
}
assert ':ok', %{
def foo
begin
yield
ensure
p :ok
end
end
def bar
foo { return }
end
bar
}
assert 'false', %{
def foo(m); m.synchronize { return 42 }; end
m = Mutex.new
foo(m)
p m.locked?
}
assert ':ok', %{
def foo(v)
1.times do
return true if v
return false
p :nok1
end
p :nok2
end
p :ok if !foo(false) and foo(true)
}
assert ":ok\n:ok", %{
def foo
raise
rescue
return 42
omgwtf
end
p :ok if foo == 42
p :ok if $!.nil?
}
assert ':ok', %{
proc do
def proc_caller(&b) b.call end
def enclosing_method
proc_caller { return :ok }
:nok
end
p enclosing_method
end.call
}, :known_bug => true
assert ':ok', %{
b = :foo.to_proc
begin
b.call
rescue ArgumentError
p :ok
end
}
assert '[2, 3, 4]', "p [1, 2, 3].map(&:succ)"
assert '42', %{
b = proc { |x| if x then p x else b.call(42) end }
b.call(nil)
}
assert '42', %{
b = nil
1.times {
x = 42
b = proc { p x }
}
x = 1
b.call
}, :known_bug => true
assert "42\n42", %{
a = b = c = nil
1.times {
1.times {
x = 42
1.times {
1.times {
c = proc {
a = proc { p x }
b = proc { p x }
}
}
c.call
}
}
}
b.call
a.call
}
assert '42', %{
END { p 42 }
}
assert '42', %{
$x = 42
END { $x += 1 }
END { p $x }
}
assert '42', %{
class Foo
def something(var)
var
end
end
class Bar < Foo
def something(var)
instance_eval do
super(var)
end
end
end
x = Bar.new
p x.something(42)
}
assert "1\n42", %{
def f
1.times {
begin
return 42
ensure
p 1
end
}
end
p f
}
assert ':ok', %{
def f
begin
1.times {
return 42
}
ensure
p :ok
end
end
f
}, :known_bug => true
assert ':ok', %{
def f
b = Proc.new { return :ok }
b.call
42
end
p f
}
assert ':ok', %{
def f2(b)
b.call
end
def f
b = Proc.new { return :ok }
f2(b)
42
end
p f
}
assert ':ok', %{
class X
def foo(&b); b.call; end
end
class Y < X
def foo(&b); super; end
end
Y.new.foo { p :ok }
}
assert '[["1-1", "1-2", "1-3"], ["2-1", "2-2", "2-3"], ["3-1", "3-2", "3-3"]]', %{
arrays = (1..3).map do |i|
(1..3).map do |j|
'%d-%d' % [i, j]
end
end
p arrays
}
assert ':ok', %{
def foo
lambda { yield }.call
end
p(foo { :ok })
}, :known_bug => true
assert ':ok', %{
def foo
bar { p :ok if block_given? }
end
def bar(&b)
b.call
end
foo {}
}, :known_bug => true
Jump to Line
Something went wrong with that request. Please try again.