diff options
author | Jari Vetoniemi <jari.vetoniemi@indooratlas.com> | 2020-03-16 18:49:26 +0900 |
---|---|---|
committer | Jari Vetoniemi <jari.vetoniemi@indooratlas.com> | 2020-03-30 00:39:06 +0900 |
commit | fcbf63e62c627deae76c1b8cb8c0876c536ed811 (patch) | |
tree | 64cb17de3f41a2b6fef2368028fbd00349946994 /jni/ruby/test/ruby/test_exception.rb |
Fresh start
Diffstat (limited to 'jni/ruby/test/ruby/test_exception.rb')
-rw-r--r-- | jni/ruby/test/ruby/test_exception.rb | 701 |
1 files changed, 701 insertions, 0 deletions
diff --git a/jni/ruby/test/ruby/test_exception.rb b/jni/ruby/test/ruby/test_exception.rb new file mode 100644 index 0000000..c68d226 --- /dev/null +++ b/jni/ruby/test/ruby/test_exception.rb @@ -0,0 +1,701 @@ +require 'test/unit' +require 'tempfile' + +class TestException < Test::Unit::TestCase + def test_exception_rescued + begin + raise "this must be handled" + assert(false) + rescue + assert(true) + end + end + + def test_exception_retry + bad = true + begin + raise "this must be handled no.2" + rescue + if bad + bad = false + retry + assert(false) + end + end + assert(true) + end + + def test_exception_in_rescue + string = "this must be handled no.3" + assert_raise_with_message(RuntimeError, string) do + begin + raise "exception in rescue clause" + rescue + raise string + end + assert(false) + end + end + + def test_exception_in_ensure + string = "exception in ensure clause" + assert_raise_with_message(RuntimeError, string) 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 + end + + def test_exception_ensure + bad = true + begin + begin + raise "this must be handled no.5" + ensure + bad = false + end + rescue + end + assert(!bad) + end + + def test_exception_ensure_2 # just duplication? + bad = true + begin + begin + raise "this must be handled no.6" + ensure + bad = false + end + rescue + end + assert(!bad) + end + + def test_errinfo_in_debug + bug9568 = EnvUtil.labeled_class("[ruby-core:61091] [Bug #9568]", RuntimeError) do + def to_s + require '\0' + rescue LoadError + self.class.to_s + end + end + + err = EnvUtil.verbose_warning do + assert_raise(bug9568) do + $DEBUG, debug = true, $DEBUG + begin + raise bug9568 + ensure + $DEBUG = debug + end + end + end + assert_include(err, bug9568.to_s) + end + + def test_errinfo_encoding_in_debug + exc = Module.new {break class_eval("class C\u{30a8 30e9 30fc} < RuntimeError; self; end".encode(Encoding::EUC_JP))} + exc.inspect + + err = EnvUtil.verbose_warning do + assert_raise(exc) do + $DEBUG, debug = true, $DEBUG + begin + raise exc + ensure + $DEBUG = debug + end + end + end + assert_include(err, exc.to_s) + end + + def test_break_ensure + bad = true + while true + begin + break + ensure + bad = false + end + end + assert(!bad) + end + + def test_catch_no_throw + assert_equal(:foo, catch {:foo}) + end + + def test_catch_throw + result = catch(:foo) { + loop do + loop do + throw :foo, true + break + end + assert(false, "should not reach here") + end + false + } + assert(result) + end + + def test_catch_throw_noarg + assert_nothing_raised(UncaughtThrowError) { + result = catch {|obj| + throw obj, :ok + assert(false, "should not reach here") + } + assert_equal(:ok, result) + } + end + + def test_uncaught_throw + tag = nil + e = assert_raise_with_message(UncaughtThrowError, /uncaught throw/) { + catch("foo") {|obj| + tag = obj.dup + throw tag, :ok + assert(false, "should not reach here") + } + assert(false, "should not reach here") + } + assert_not_nil(tag) + assert_same(tag, e.tag) + assert_equal(:ok, e.value) + end + + def test_catch_throw_in_require + bug7185 = '[ruby-dev:46234]' + Tempfile.create(["dep", ".rb"]) {|t| + t.puts("throw :extdep, 42") + t.close + assert_equal(42, assert_throw(:extdep, bug7185) {require t.path}, bug7185) + } + end + + def test_else_no_exception + begin + assert(true) + rescue + assert(false) + else + assert(true) + end + end + + def test_else_raised + begin + assert(true) + raise + assert(false) + rescue + assert(true) + else + assert(false) + end + end + + def test_else_nested_no_exception + begin + assert(true) + begin + assert(true) + rescue + assert(false) + else + assert(true) + end + assert(true) + rescue + assert(false) + else + assert(true) + end + end + + def test_else_nested_rescued + 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 + end + + def test_else_nested_unrescued + 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 + end + + def test_else_nested_rescued_reraise + 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_type_error_message_encoding + c = eval("Module.new do break class C\u{4032}; self; end; end") + o = c.new + assert_raise_with_message(TypeError, /C\u{4032}/) do + ""[o] + end + c.class_eval {def to_int; self; end} + assert_raise_with_message(TypeError, /C\u{4032}/) do + ""[o] + end + c.class_eval {def to_a; self; end} + assert_raise_with_message(TypeError, /C\u{4032}/) do + [*o] + end + 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_thread_signal_location + _, stderr, _ = EnvUtil.invoke_ruby("--disable-gems -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_to_s + e = StandardError.new("foo") + assert_equal("foo", e.to_s) + + def (s = Object.new).to_s + "bar" + end + e = StandardError.new(s) + assert_equal("bar", e.to_s) + 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_send([e, :success?], "success by default") + + begin + exit(true) + rescue SystemExit => e + end + assert_send([e, :success?], "true means success") + + begin + exit(false) + rescue SystemExit => e + end + assert_not_send([e, :success?], "false means failure") + + begin + abort + rescue SystemExit => e + end + assert_not_send([e, :success?], "abort means failure") + end + + def test_nomethoderror + bug3237 = '[ruby-core:29948]' + str = "\u2600" + id = :"\u2604" + msg = "undefined method `#{id}' for #{str.inspect}:String" + assert_raise_with_message(NoMethodError, msg, bug3237) do + str.__send__(id) + end + end + + def test_errno + assert_equal(Encoding.find("locale"), Errno::EINVAL.new.message.encoding) + end + + def test_too_many_args_in_eval + bug5720 = '[ruby-core:41520]' + arg_string = (0...140000).to_a.join(", ") + assert_raise(SystemStackError, bug5720) {eval "raise(#{arg_string})"} + end + + def test_systemexit_new + e0 = SystemExit.new + assert_equal(0, e0.status) + assert_equal("SystemExit", e0.message) + ei = SystemExit.new(3) + assert_equal(3, ei.status) + assert_equal("SystemExit", ei.message) + es = SystemExit.new("msg") + assert_equal(0, es.status) + assert_equal("msg", es.message) + eis = SystemExit.new(7, "msg") + assert_equal(7, eis.status) + assert_equal("msg", eis.message) + + bug5728 = '[ruby-dev:44951]' + et = SystemExit.new(true) + assert_equal(true, et.success?, bug5728) + assert_equal("SystemExit", et.message, bug5728) + ef = SystemExit.new(false) + assert_equal(false, ef.success?, bug5728) + assert_equal("SystemExit", ef.message, bug5728) + ets = SystemExit.new(true, "msg") + assert_equal(true, ets.success?, bug5728) + assert_equal("msg", ets.message, bug5728) + efs = SystemExit.new(false, "msg") + assert_equal(false, efs.success?, bug5728) + assert_equal("msg", efs.message, bug5728) + end + + def test_exception_in_name_error_to_str + bug5575 = '[ruby-core:41612]' + Tempfile.create(["test_exception_in_name_error_to_str", ".rb"]) do |t| + t.puts <<-EOC + begin + BasicObject.new.inspect + rescue + $!.inspect + end + EOC + t.close + assert_nothing_raised(NameError, bug5575) do + load(t.path) + end + end + end + + def test_equal + bug5865 = '[ruby-core:41979]' + assert_equal(RuntimeError.new("a"), RuntimeError.new("a"), bug5865) + assert_not_equal(RuntimeError.new("a"), StandardError.new("a"), bug5865) + end + + def test_exception_in_exception_equal + bug5865 = '[ruby-core:41979]' + Tempfile.create(["test_exception_in_exception_equal", ".rb"]) do |t| + t.puts <<-EOC + o = Object.new + def o.exception(arg) + end + _ = RuntimeError.new("a") == o + EOC + t.close + assert_nothing_raised(ArgumentError, bug5865) do + load(t.path) + end + end + end + + Bug4438 = '[ruby-core:35364]' + + def test_rescue_single_argument + assert_raise(TypeError, Bug4438) do + begin + raise + rescue 1 + end + end + end + + def test_rescue_splat_argument + assert_raise(TypeError, Bug4438) do + begin + raise + rescue *Array(1) + end + 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 m + m(&->{return 0}) + 42 + end + + def test_stackoverflow + feature6216 = '[ruby-core:43794] [Feature #6216]' + e = assert_raise(SystemStackError, feature6216) {m} + level = e.backtrace.size + assert_operator(level, :>, 10, feature6216) + + feature6216 = '[ruby-core:63377] [Feature #6216]' + e = assert_raise(SystemStackError, feature6216) {raise e} + assert_equal(level, e.backtrace.size, feature6216) + end + + def test_machine_stackoverflow + bug9109 = '[ruby-dev:47804] [Bug #9109]' + assert_separately(%w[--disable-gem], <<-SRC) + assert_raise(SystemStackError, #{bug9109.dump}) { + h = {a: ->{h[:a].call}} + h[:a].call + } + SRC + rescue SystemStackError + end + + def test_machine_stackoverflow_by_define_method + bug9454 = '[ruby-core:60113] [Bug #9454]' + assert_separately(%w[--disable-gem], <<-SRC) + assert_raise(SystemStackError, #{bug9454.dump}) { + define_method(:foo) {self.foo} + self.foo + } + SRC + rescue SystemStackError + end + + def test_cause + msg = "[Feature #8257]" + cause = nil + e = assert_raise(StandardError) { + begin + raise msg + rescue => e + cause = e.cause + raise StandardError + end + } + assert_nil(cause, msg) + cause = e.cause + assert_instance_of(RuntimeError, cause, msg) + assert_equal(msg, cause.message, msg) + end + + def test_cause_reraised + msg = "[Feature #8257]" + e = assert_raise(RuntimeError) { + begin + raise msg + rescue => e + raise e + end + } + assert_not_same(e, e.cause, "#{msg}: should not be recursive") + end + + def test_raise_with_cause + msg = "[Feature #8257]" + cause = ArgumentError.new("foobar") + e = assert_raise(RuntimeError) {raise msg, cause: cause} + assert_same(cause, e.cause) + end + + def test_cause_with_no_arguments + cause = ArgumentError.new("foobar") + assert_raise_with_message(ArgumentError, /with no arguments/) do + raise cause: cause + end + end + + def test_unknown_option + bug = '[ruby-core:63203] [Feature #8257] should pass unknown options' + + exc = Class.new(RuntimeError) do + attr_reader :arg + def initialize(msg = nil) + @arg = msg + super(msg) + end + end + + e = assert_raise(exc, bug) {raise exc, "foo" => "bar", foo: "bar"} + assert_equal({"foo" => "bar", foo: "bar"}, e.arg, bug) + + e = assert_raise(exc, bug) {raise exc, "foo" => "bar", foo: "bar", cause: "zzz"} + assert_equal({"foo" => "bar", foo: "bar"}, e.arg, bug) + + e = assert_raise(exc, bug) {raise exc, {}} + assert_equal({}, e.arg, bug) + end + + def test_anonymous_message + assert_in_out_err([], "raise Class.new(RuntimeError), 'foo'", [], /foo\n/) + end + + def test_name_error_info + obj = BasicObject.new + e = assert_raise(NameError) { + obj.instance_eval("Object") + } + assert_equal(:Object, e.name) + e = assert_raise(NameError) { + obj.instance_eval {foo} + } + assert_equal(:foo, e.name) + e = assert_raise(NoMethodError) { + obj.foo(1, 2) + } + assert_equal(:foo, e.name) + assert_equal([1, 2], e.args) + end + + def test_output_string_encoding + # "\x82\xa0" in cp932 is "\u3042" (Japanese hiragana 'a') + # change $stderr to force calling rb_io_write() instead of fwrite() + assert_in_out_err(["-Eutf-8:cp932"], '# coding: cp932 +$stderr = $stdout; raise "\x82\xa0"') do |outs, errs, status| + assert_equal 1, outs.size + assert_equal 0, errs.size + err = outs.first.force_encoding('utf-8') + assert err.valid_encoding?, 'must be valid encoding' + assert_match /\u3042/, err + end + end + + def test_multibyte_and_newline + bug10727 = '[ruby-core:67473] [Bug #10727]' + assert_in_out_err([], <<-'end;', [], /\u{306b 307b 3093 3054} \(E\)\n\u{6539 884c}/, bug10727, encoding: "UTF-8") + class E < StandardError + def initialize + super("\u{306b 307b 3093 3054}\n\u{6539 884c}") + end + end + raise E + end; + end +end |