block.rb

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"
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
}

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
}

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
}

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 })
}

assert ':ok', %{
  def foo
    bar { p :ok if block_given? }
  end
  def bar(&b)
    b.call
  end
  foo {}
}