mirror of
https://github.com/ruby/ruby.git
synced 2022-11-09 12:17:21 -05:00
b91f5c75ed
* vm.c (rb_vm_jump_tag_but_local_jump): pass through thrown objects. [ruby-dev:46234] [Bug #7185] * vm_eval.c (rb_eval_cmd): if state is non-zero, val should be nil and rb_vm_jump_tag_but_local_jump() just jump tag. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_9_3@37551 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
395 lines
7.4 KiB
Ruby
395 lines
7.4 KiB
Ruby
require 'test/unit'
|
|
require 'tempfile'
|
|
require_relative 'envutil'
|
|
|
|
class TestException < Test::Unit::TestCase
|
|
def test_exception
|
|
begin
|
|
raise "this must be handled"
|
|
assert(false)
|
|
rescue
|
|
assert(true)
|
|
end
|
|
|
|
$bad = true
|
|
begin
|
|
raise "this must be handled no.2"
|
|
rescue
|
|
if $bad
|
|
$bad = false
|
|
retry
|
|
assert(false)
|
|
end
|
|
end
|
|
assert(true)
|
|
|
|
# exception in rescue clause
|
|
$string = "this must be handled no.3"
|
|
e = assert_raise(RuntimeError) do
|
|
begin
|
|
raise "exception in rescue clause"
|
|
rescue
|
|
raise $string
|
|
end
|
|
assert(false)
|
|
end
|
|
assert_equal($string, e.message)
|
|
|
|
# exception in ensure clause
|
|
$string = "exception in ensure clause"
|
|
e = assert_raise(RuntimeError) do
|
|
begin
|
|
raise "this must be handled no.4"
|
|
ensure
|
|
assert_instance_of(RuntimeError, $!)
|
|
assert_equal("this must be handled no.4", $!.message)
|
|
raise "exception in ensure clause"
|
|
end
|
|
assert(false)
|
|
end
|
|
assert_equal($string, e.message)
|
|
|
|
$bad = true
|
|
begin
|
|
begin
|
|
raise "this must be handled no.5"
|
|
ensure
|
|
$bad = false
|
|
end
|
|
rescue
|
|
end
|
|
assert(!$bad)
|
|
|
|
$bad = true
|
|
begin
|
|
begin
|
|
raise "this must be handled no.6"
|
|
ensure
|
|
$bad = false
|
|
end
|
|
rescue
|
|
end
|
|
assert(!$bad)
|
|
|
|
$bad = true
|
|
while true
|
|
begin
|
|
break
|
|
ensure
|
|
$bad = false
|
|
end
|
|
end
|
|
assert(!$bad)
|
|
|
|
assert(catch(:foo) {
|
|
loop do
|
|
loop do
|
|
throw :foo, true
|
|
break
|
|
end
|
|
break
|
|
assert(false) # should no reach here
|
|
end
|
|
false
|
|
})
|
|
end
|
|
|
|
def test_catch_throw_in_require
|
|
bug7185 = '[ruby-dev:46234]'
|
|
t = Tempfile.open(["dep", ".rb"])
|
|
t.puts("throw :extdep, 42")
|
|
t.close
|
|
assert_equal(42, catch(:extdep) {require t.path}, bug7185)
|
|
ensure
|
|
t.close! if t
|
|
end
|
|
|
|
def test_else
|
|
begin
|
|
assert(true)
|
|
rescue
|
|
assert(false)
|
|
else
|
|
assert(true)
|
|
end
|
|
|
|
begin
|
|
assert(true)
|
|
raise
|
|
assert(false)
|
|
rescue
|
|
assert(true)
|
|
else
|
|
assert(false)
|
|
end
|
|
|
|
begin
|
|
assert(true)
|
|
begin
|
|
assert(true)
|
|
rescue
|
|
assert(false)
|
|
else
|
|
assert(true)
|
|
end
|
|
assert(true)
|
|
rescue
|
|
assert(false)
|
|
else
|
|
assert(true)
|
|
end
|
|
|
|
begin
|
|
assert(true)
|
|
begin
|
|
assert(true)
|
|
raise
|
|
assert(false)
|
|
rescue
|
|
assert(true)
|
|
else
|
|
assert(false)
|
|
end
|
|
assert(true)
|
|
rescue
|
|
assert(false)
|
|
else
|
|
assert(true)
|
|
end
|
|
|
|
begin
|
|
assert(true)
|
|
begin
|
|
assert(true)
|
|
rescue
|
|
assert(false)
|
|
else
|
|
assert(true)
|
|
end
|
|
assert(true)
|
|
raise
|
|
assert(false)
|
|
rescue
|
|
assert(true)
|
|
else
|
|
assert(false)
|
|
end
|
|
|
|
begin
|
|
assert(true)
|
|
begin
|
|
assert(true)
|
|
raise
|
|
assert(false)
|
|
rescue
|
|
assert(true)
|
|
else
|
|
assert(false)
|
|
end
|
|
assert(true)
|
|
raise
|
|
assert(false)
|
|
rescue
|
|
assert(true)
|
|
else
|
|
assert(false)
|
|
end
|
|
end
|
|
|
|
def test_raise_with_wrong_number_of_arguments
|
|
assert_raise(TypeError) { raise nil }
|
|
assert_raise(TypeError) { raise 1, 1 }
|
|
assert_raise(ArgumentError) { raise 1, 1, 1, 1 }
|
|
end
|
|
|
|
def test_errat
|
|
assert_in_out_err([], "p $@", %w(nil), [])
|
|
|
|
assert_in_out_err([], "$@ = 1", [], /\$! not set \(ArgumentError\)$/)
|
|
|
|
assert_in_out_err([], <<-INPUT, [], /backtrace must be Array of String \(TypeError\)$/)
|
|
begin
|
|
raise
|
|
rescue
|
|
$@ = 1
|
|
end
|
|
INPUT
|
|
|
|
assert_in_out_err([], <<-INPUT, [], /^foo: unhandled exception$/)
|
|
begin
|
|
raise
|
|
rescue
|
|
$@ = 'foo'
|
|
raise
|
|
end
|
|
INPUT
|
|
|
|
assert_in_out_err([], <<-INPUT, [], /^foo: unhandled exception\s+from bar\s+from baz$/)
|
|
begin
|
|
raise
|
|
rescue
|
|
$@ = %w(foo bar baz)
|
|
raise
|
|
end
|
|
INPUT
|
|
end
|
|
|
|
def test_safe4
|
|
cmd = proc{raise SystemExit}
|
|
safe0_p = proc{|*args| args}
|
|
|
|
test_proc = proc {
|
|
$SAFE = 4
|
|
begin
|
|
cmd.call
|
|
rescue SystemExit => e
|
|
safe0_p["SystemExit: #{e.inspect}"]
|
|
raise e
|
|
rescue Exception => e
|
|
safe0_p["Exception (NOT SystemExit): #{e.inspect}"]
|
|
raise e
|
|
end
|
|
}
|
|
assert_raise(SystemExit, '[ruby-dev:38760]') {test_proc.call}
|
|
end
|
|
|
|
def test_thread_signal_location
|
|
stdout, stderr, status = EnvUtil.invoke_ruby("-d", <<-RUBY, false, true)
|
|
Thread.start do
|
|
begin
|
|
Process.kill(:INT, $$)
|
|
ensure
|
|
raise "in ensure"
|
|
end
|
|
end.join
|
|
RUBY
|
|
assert_not_match(/:0/, stderr, "[ruby-dev:39116]")
|
|
end
|
|
|
|
def test_errinfo
|
|
begin
|
|
raise "foo"
|
|
assert(false)
|
|
rescue => e
|
|
assert_equal(e, $!)
|
|
1.times { assert_equal(e, $!) }
|
|
end
|
|
|
|
assert_equal(nil, $!)
|
|
end
|
|
|
|
def test_inspect
|
|
assert_equal("#<Exception: Exception>", Exception.new.inspect)
|
|
|
|
e = Class.new(Exception)
|
|
e.class_eval do
|
|
def to_s; ""; end
|
|
end
|
|
assert_equal(e.inspect, e.new.inspect)
|
|
end
|
|
|
|
def test_set_backtrace
|
|
e = Exception.new
|
|
|
|
e.set_backtrace("foo")
|
|
assert_equal(["foo"], e.backtrace)
|
|
|
|
e.set_backtrace(%w(foo bar baz))
|
|
assert_equal(%w(foo bar baz), e.backtrace)
|
|
|
|
assert_raise(TypeError) { e.set_backtrace(1) }
|
|
assert_raise(TypeError) { e.set_backtrace([1]) }
|
|
end
|
|
|
|
def test_exit_success_p
|
|
begin
|
|
exit
|
|
rescue SystemExit => e
|
|
end
|
|
assert(e.success?)
|
|
|
|
begin
|
|
abort
|
|
rescue SystemExit => e
|
|
end
|
|
assert(!e.success?)
|
|
end
|
|
|
|
def test_nomethoderror
|
|
bug3237 = '[ruby-core:29948]'
|
|
str = "\u2600"
|
|
id = :"\u2604"
|
|
e = assert_raise(NoMethodError) {str.__send__(id)}
|
|
assert_equal("undefined method `#{id}' for #{str.inspect}:String", e.message, bug3237)
|
|
end
|
|
|
|
def test_errno
|
|
assert_equal(Encoding.find("locale"), Errno::EINVAL.new.message.encoding)
|
|
end
|
|
|
|
def test_exception_in_name_error_to_str
|
|
bug5575 = '[ruby-core:41612]'
|
|
t = Tempfile.new(["test_exception_in_name_error_to_str", ".rb"])
|
|
t.puts <<-EOC
|
|
begin
|
|
BasicObject.new.inspect
|
|
rescue
|
|
$!.inspect
|
|
end
|
|
EOC
|
|
t.close
|
|
assert_nothing_raised(NameError, bug5575) do
|
|
load(t.path)
|
|
end
|
|
end
|
|
|
|
def test_to_s_taintness_propagation
|
|
for exc in [Exception, NameError]
|
|
m = "abcdefg"
|
|
e = exc.new(m)
|
|
e.taint
|
|
s = e.to_s
|
|
assert_equal(false, m.tainted?,
|
|
"#{exc}#to_s should not propagate taintness")
|
|
assert_equal(false, s.tainted?,
|
|
"#{exc}#to_s should not propagate taintness")
|
|
end
|
|
|
|
o = Object.new
|
|
def o.to_str
|
|
"foo"
|
|
end
|
|
o.taint
|
|
e = NameError.new(o)
|
|
s = e.to_s
|
|
assert_equal(false, s.tainted?)
|
|
end
|
|
|
|
def test_exception_to_s_should_not_propagate_untrustedness
|
|
favorite_lang = "Ruby"
|
|
|
|
for exc in [Exception, NameError]
|
|
assert_raise(SecurityError) do
|
|
lambda {
|
|
$SAFE = 4
|
|
exc.new(favorite_lang).to_s
|
|
favorite_lang.replace("Python")
|
|
}.call
|
|
end
|
|
end
|
|
|
|
assert_raise(SecurityError) do
|
|
lambda {
|
|
$SAFE = 4
|
|
o = Object.new
|
|
o.singleton_class.send(:define_method, :to_str) {
|
|
favorite_lang
|
|
}
|
|
NameError.new(o).to_s
|
|
favorite_lang.replace("Python")
|
|
}.call
|
|
end
|
|
|
|
assert_equal("Ruby", favorite_lang)
|
|
end
|
|
end
|