test_begin "test_proc"

assert_equal %q{[1, 2, 3]}, proc{
  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}, proc{
  def make_proc(&b)
    b
  end
  
  def make_closure
    @proc_a = 0
    make_proc{
      @proc_a+=1
    }
  end
  
  cl = make_closure
  cl.call + cl.call * cl.call
}
assert_equal %q{ok}, proc{
  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]}, proc{
  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}, proc{
  def iter
    yield
  end
  
  def getproc &b
    b
  end
  
  iter{
    bvar = 3
    getproc{
      bvar2 = 4
      bvar * bvar2
    }
  }.call
}
# assert_equal %q{200}, proc{
#   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]}, proc{
#   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}, proc{
  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]}, proc{
  Const = :top
  class C
    Const = :C
    $pr = proc{
      (1..2).map{
        Const
      }
    }
  end
  $pr.call
}
# assert_equal %q{top}, proc{
#   Const = :top
#   class C
#     Const = :C
#   end
#   pr = proc{
#     Const
#   }
#   C.class_eval %q{
#     pr.call
#   }
# }
assert_equal %q{1}, proc{
  def m(&b)
    b
  end

  m{|e_proctest| e_proctest}.call(1)
}
assert_equal %q{12}, proc{
  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]]}, proc{
  [
  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]]]}, proc{
  [
  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{0}, proc{
#   pr = proc{
#     $SAFE
#   }
#   $SAFE = 1
#   pr.call
# }
# assert_equal %q{[1, 0]}, proc{
#   pr = proc{
#     $SAFE += 1
#   }
#   [pr.call, $SAFE]
# }
assert_equal %q{1}, proc{
  def m(&b)
    b
  end
  m{1}.call
}
assert_equal %q{3}, proc{
  def m(&b)
    b
  end

  m{
    a = 1
    a + 2
  }.call
}
# assert_equal %Q{ok\n}, proc{
#   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', proc{
  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', proc{
  lambda {
    break :ok
    :ng
  }.call
}, '[ruby-dev:34646]'

assert_equal %q{[:bar, :foo]}, proc{
  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', proc{
   $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', proc{
  lambda { a = lambda { return }; $x = :ng; a[]; $x = :ok }.call
  $x
}, '[ruby-core:17164]'

assert_equal 'ok', proc{
  lambda { a = lambda { break }; $x = :ng; a[]; $x = :ok }.call
  $x
}, '[ruby-core:17164]'

# assert_equal 'ok', proc{
#   def def8
#     $x = :ng
#     lambda { a = Proc.new { return }; a[]}.call
#     $x = :ok
#   end
#   def8
#   $x
# }, '[ruby-core:17164]'


assert_equal 'ok', proc{
   def def9
      lambda {|a| $x = :ok; a[]; $x = :ng }.call(Proc.new { return })
      $x = :ng
   end
   def9
   $x
}, '[ruby-core:17164]'

# assert_equal 'ok', proc{
#    def def10
#      $x = :ng
#      lambda { 1.times { return } }.call
#      $x = :ok
#    end
#    $x = :ok
#    def10
#    $x
# }, '[ruby-core:17164]'

# assert_equal 'ok', proc{
#    def def11
#       yield
#    end
#    begin
#       lambda { def11 { return } }.call
#    rescue LocalJumpError
#       :ng
#    else
#       :ok
#    end
# }, '[ruby-core:17164]'

assert_equal 'ok', proc{
   def def12
      b = Proc.new { $x = :ng; lambda { return }.call; $x = :ok }.call
   end
   def12
   $x
}, '[ruby-core:17164]'

assert_equal 'ok', proc{
  def m
    pr = proc{
      proc{
        return :ok
      }
    }.call
    pr.call
    :ng
  end
  m()
}

assert_equal 'ok', proc{
  class Foo
    def call_it
      p = Proc.new
      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!', proc{
#   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', proc{
#   o = Object.new
#   def o.write(s); end
#   $stderr = o
#   at_exit{
#     print $!.message
#   }
#   raise "ok"
# }

test_end