kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Add FrozenError as a subclass of RuntimeError

Browse source 
FrozenError will be used instead of RuntimeError for exceptions
raised when there is an attempt to modify a frozen object. The
reason for this change is to differentiate exceptions related
to frozen objects from generic exceptions such as those generated
by Kernel#raise without an exception class.

From: Jeremy Evans <code@jeremyevans.net>
Signed-off-by: Urabe Shyouhei <shyouhei@ruby-lang.org>


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@61131 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
This commit is contained in:
shyouhei 2017-12-12 00:46:34 +00:00
parent 0b31ce0047
commit b57915eddc
29 changed files with 97 additions and 89 deletions
Download patch file Download diff file Expand all files Collapse all files

19
error.c
View file

@ -804,6 +804,7 @@ VALUE rb_eSignal;
VALUE rb_eFatal;
VALUE rb_eStandardError;
VALUE rb_eRuntimeError;
VALUE rb_eFrozenError;
VALUE rb_eTypeError;
VALUE rb_eArgError;
VALUE rb_eIndexError;
@ -2011,16 +2012,21 @@ syserr_eqq(VALUE self, VALUE exc)
*/
/*
* Document-class: RuntimeError
* Document-class: FrozenError
*
* A generic error class raised when an invalid operation is attempted.
* Raised when there is an attempt to modify a frozen object.
*
* [1, 2, 3].freeze << 4
*
* <em>raises the exception:</em>
*
* RuntimeError: can't modify frozen Array
* FrozenError: can't modify frozen Array
*/
/*
* Document-class: RuntimeError
*
* A generic error class raised when an invalid operation is attempted.
* Kernel#raise will raise a RuntimeError if no Exception class is
* specified.
*
@ -2233,6 +2239,7 @@ Init_Exception(void)
rb_define_method(rb_eNoMethodError, "private_call?", nometh_err_private_call_p, 0);
rb_eRuntimeError = rb_define_class("RuntimeError", rb_eStandardError);
rb_eFrozenError = rb_define_class("FrozenError", rb_eRuntimeError);
rb_eSecurityError = rb_define_class("SecurityError", rb_eException);
rb_eNoMemError = rb_define_class("NoMemoryError", rb_eException);
rb_eEncodingError = rb_define_class("EncodingError", rb_eStandardError);
@ -2588,7 +2595,7 @@ rb_load_fail(VALUE path, const char *err)
void
rb_error_frozen(const char *what)
{
rb_raise(rb_eRuntimeError, "can't modify frozen %s", what);
rb_raise(rb_eFrozenError, "can't modify frozen %s", what);
}
void
@ -2601,11 +2608,11 @@ rb_error_frozen_object(VALUE frozen_obj)
VALUE path = rb_ary_entry(debug_info, 0);
VALUE line = rb_ary_entry(debug_info, 1);
rb_raise(rb_eRuntimeError, "can't modify frozen %"PRIsVALUE", created at %"PRIsVALUE":%"PRIsVALUE,
rb_raise(rb_eFrozenError, "can't modify frozen %"PRIsVALUE", created at %"PRIsVALUE":%"PRIsVALUE,
CLASS_OF(frozen_obj), path, line);
}
else {
rb_raise(rb_eRuntimeError, "can't modify frozen %"PRIsVALUE,
rb_raise(rb_eFrozenError, "can't modify frozen %"PRIsVALUE,
CLASS_OF(frozen_obj));
}
}

1
include/ruby/ruby.h
View file

@ -1946,6 +1946,7 @@ RUBY_EXTERN VALUE rb_eKeyError;
RUBY_EXTERN VALUE rb_eRangeError;
RUBY_EXTERN VALUE rb_eIOError;
RUBY_EXTERN VALUE rb_eRuntimeError;
RUBY_EXTERN VALUE rb_eFrozenError;
RUBY_EXTERN VALUE rb_eSecurityError;
RUBY_EXTERN VALUE rb_eSystemCallError;
RUBY_EXTERN VALUE rb_eThreadError;

2
object.c
View file

@ -1315,7 +1315,7 @@ rb_obj_infect(VALUE victim, VALUE carrier)
*
* <em>produces:</em>
*
* prog.rb:3:in `<<': can't modify frozen Array (RuntimeError)
* prog.rb:3:in `<<': can't modify frozen Array (FrozenError)
* from prog.rb:3
*
* Objects of the following classes are always frozen: Integer,

4
test/-ext-/string/test_enc_associate.rb
View file

@ -7,8 +7,8 @@ class Test_StrEncAssociate < Test::Unit::TestCase
s = Bug::String.new("abc")
s.force_encoding(Encoding::US_ASCII)
s.freeze
assert_raise(RuntimeError) {s.associate_encoding!(Encoding::US_ASCII)}
assert_raise(RuntimeError) {s.associate_encoding!(Encoding::UTF_8)}
assert_raise(FrozenError) {s.associate_encoding!(Encoding::US_ASCII)}
assert_raise(FrozenError) {s.associate_encoding!(Encoding::UTF_8)}
end
Encoding.list.select(&:dummy?).each do |enc|

4
test/date/test_date_marshal.rb
View file

@ -30,13 +30,13 @@ class TestDateMarshal < Test::Unit::TestCase
a = d.marshal_dump
d.freeze
assert(d.frozen?)
assert_raise(RuntimeError){d.marshal_load(a)}
assert_raise(FrozenError){d.marshal_load(a)}
d = DateTime.now
a = d.marshal_dump
d.freeze
assert(d.frozen?)
assert_raise(RuntimeError){d.marshal_load(a)}
assert_raise(FrozenError){d.marshal_load(a)}
end
end

2
test/dbm/test_dbm.rb
View file

@ -625,7 +625,7 @@ if defined? DBM
def test_freeze
DBM.open("#{@tmproot}/a") {|d|
d.freeze
assert_raise(RuntimeError) { d["k"] = "v" }
assert_raise(FrozenError) { d["k"] = "v" }
}
end
end

2
test/gdbm/test_gdbm.rb
View file

@ -722,7 +722,7 @@ if defined? GDBM
def test_freeze
GDBM.open("#{@tmproot}/a.dbm") {|d|
d.freeze
assert_raise(RuntimeError) { d["k"] = "v" }
assert_raise(FrozenError) { d["k"] = "v" }
}
end
end

2
test/pathname/test_pathname.rb
View file

@ -635,7 +635,7 @@ class TestPathname < Test::Unit::TestCase
obj = Pathname.new("a")
obj.freeze
assert_equal(false, obj.tainted?)
assert_raise(RuntimeError) { obj.taint }
assert_raise(FrozenError) { obj.taint }
obj = Pathname.new("a")
obj.taint

26
test/ruby/test_array.rb
View file

@ -601,7 +601,7 @@ class TestArray < Test::Unit::TestCase
assert_equal([4, 5, 4, 5, 4, 5], b)
assert_raise(TypeError) { [0].concat(:foo) }
assert_raise(RuntimeError) { [0].freeze.concat(:foo) }
assert_raise(FrozenError) { [0].freeze.concat(:foo) }
end
def test_count
@ -1299,10 +1299,10 @@ class TestArray < Test::Unit::TestCase
fa = a.dup.freeze
assert_nothing_raised(RuntimeError) { a.replace(a) }
assert_raise(RuntimeError) { fa.replace(fa) }
assert_raise(FrozenError) { fa.replace(fa) }
assert_raise(ArgumentError) { fa.replace() }
assert_raise(TypeError) { a.replace(42) }
assert_raise(RuntimeError) { fa.replace(42) }
assert_raise(FrozenError) { fa.replace(42) }
end
def test_reverse
@ -1530,7 +1530,7 @@ class TestArray < Test::Unit::TestCase
o2 = o1.clone
ary << o1 << o2
orig = ary.dup
assert_raise(RuntimeError, "frozen during comparison") {ary.sort!}
assert_raise(FrozenError, "frozen during comparison") {ary.sort!}
assert_equal(orig, ary, "must not be modified once frozen")
end
@ -1762,7 +1762,7 @@ class TestArray < Test::Unit::TestCase
f = a.dup.freeze
assert_raise(ArgumentError) { a.uniq!(1) }
assert_raise(ArgumentError) { f.uniq!(1) }
assert_raise(RuntimeError) { f.uniq! }
assert_raise(FrozenError) { f.uniq! }
assert_nothing_raised do
a = [ {c: "b"}, {c: "r"}, {c: "w"}, {c: "g"}, {c: "g"} ]
@ -1808,7 +1808,7 @@ class TestArray < Test::Unit::TestCase
def test_uniq_bang_with_freeze
ary = [1,2]
orig = ary.dup
assert_raise(RuntimeError, "frozen during comparison") {
assert_raise(FrozenError, "frozen during comparison") {
ary.uniq! {|v| ary.freeze; 1}
}
assert_equal(orig, ary, "must not be modified once frozen")
@ -2121,7 +2121,7 @@ class TestArray < Test::Unit::TestCase
assert_raise(ArgumentError) { [0][0, 0, 0] = 0 }
assert_raise(ArgumentError) { [0].freeze[0, 0, 0] = 0 }
assert_raise(TypeError) { [0][:foo] = 0 }
assert_raise(RuntimeError) { [0].freeze[:foo] = 0 }
assert_raise(FrozenError) { [0].freeze[:foo] = 0 }
end
def test_first2
@ -2146,8 +2146,8 @@ class TestArray < Test::Unit::TestCase
end
def test_unshift_error
assert_raise(RuntimeError) { [].freeze.unshift('cat') }
assert_raise(RuntimeError) { [].freeze.unshift() }
assert_raise(FrozenError) { [].freeze.unshift('cat') }
assert_raise(FrozenError) { [].freeze.unshift() }
end
def test_aref
@ -2208,7 +2208,7 @@ class TestArray < Test::Unit::TestCase
assert_equal([0, 1, 2], a.insert(-1, 2))
assert_equal([0, 1, 3, 2], a.insert(-2, 3))
assert_raise_with_message(IndexError, /-6/) { a.insert(-6, 4) }
assert_raise(RuntimeError) { [0].freeze.insert(0)}
assert_raise(FrozenError) { [0].freeze.insert(0)}
assert_raise(ArgumentError) { [0].freeze.insert }
end
@ -2389,8 +2389,8 @@ class TestArray < Test::Unit::TestCase
assert_raise(ArgumentError) { a.flatten!(1, 2) }
assert_raise(TypeError) { a.flatten!(:foo) }
assert_raise(ArgumentError) { f.flatten!(1, 2) }
assert_raise(RuntimeError) { f.flatten! }
assert_raise(RuntimeError) { f.flatten!(:foo) }
assert_raise(FrozenError) { f.flatten! }
assert_raise(FrozenError) { f.flatten!(:foo) }
end
def test_shuffle
@ -2728,7 +2728,7 @@ class TestArray < Test::Unit::TestCase
assert_equal([], a.rotate!(13))
assert_equal([], a.rotate!(-13))
a = [].freeze
assert_raise_with_message(RuntimeError, /can\'t modify frozen/) {a.rotate!}
assert_raise_with_message(FrozenError, /can\'t modify frozen/) {a.rotate!}
a = [1,2,3]
assert_raise(ArgumentError) { a.rotate!(1, 1) }
end

4
test/ruby/test_class.rb
View file

@ -443,14 +443,14 @@ class TestClass < Test::Unit::TestCase
obj = Object.new
c = obj.singleton_class
obj.freeze
assert_raise_with_message(RuntimeError, /frozen object/) {
assert_raise_with_message(FrozenError, /frozen object/) {
c.class_eval {def f; end}
}
end
def test_singleton_class_message
c = Class.new.freeze
assert_raise_with_message(RuntimeError, /frozen Class/) {
assert_raise_with_message(FrozenError, /frozen Class/) {
def c.f; end
}
end

4
test/ruby/test_enumerator.rb
View file

@ -79,7 +79,7 @@ class TestEnumerator < Test::Unit::TestCase
enum = @obj.to_enum
assert_raise(NoMethodError) { enum.each {} }
enum.freeze
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
capture_io do
# warning: Enumerator.new without a block is deprecated; use Object#to_enum
enum.__send__(:initialize, @obj, :foo)
@ -440,7 +440,7 @@ class TestEnumerator < Test::Unit::TestCase
assert_equal([1, 2, 3], a)
g.freeze
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
g.__send__ :initialize, proc { |y| y << 4 << 5 }
}

2
test/ruby/test_eval.rb
View file

@ -506,7 +506,7 @@ class TestEval < Test::Unit::TestCase
def test_fstring_instance_eval
bug = "[ruby-core:78116] [Bug #12930]".freeze
assert_same bug, (bug.instance_eval {self})
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
bug.instance_eval {@ivar = true}
}
end

4
test/ruby/test_hash.rb
View file

@ -1031,8 +1031,8 @@ class TestHash < Test::Unit::TestCase
assert_raise(TypeError) { h2.replace(1) }
h2.freeze
assert_raise(ArgumentError) { h2.replace() }
assert_raise(RuntimeError) { h2.replace(h1) }
assert_raise(RuntimeError) { h2.replace(42) }
assert_raise(FrozenError) { h2.replace(h1) }
assert_raise(FrozenError) { h2.replace(42) }
end
def test_size2

2
test/ruby/test_lazy_enumerator.rb
View file

@ -32,7 +32,7 @@ class TestLazyEnumerator < Test::Unit::TestCase
a = [1, 2, 3].lazy
a.freeze
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
a.__send__ :initialize, [4, 5], &->(y, *v) { y << yield(*v) }
}
end

2
test/ruby/test_literal.rb
View file

@ -185,7 +185,7 @@ class TestRubyLiteral < Test::Unit::TestCase
str = RubyVM::InstructionSequence.compile(src, f, f, n, opt).eval
assert_equal("foo-1", str)
assert_predicate(str, :frozen?)
assert_raise_with_message(RuntimeError, /created at #{Regexp.quote(f)}:#{n}/) {
assert_raise_with_message(FrozenError, /created at #{Regexp.quote(f)}:#{n}/) {
str << "x"
}
end

2
test/ruby/test_marshal.rb
View file

@ -568,7 +568,7 @@ class TestMarshal < Test::Unit::TestCase
s.instance_variable_set(:@t, 42)
t = Bug8276.new(s)
s = Marshal.dump(t)
assert_raise(RuntimeError) {Marshal.load(s)}
assert_raise(FrozenError) {Marshal.load(s)}
end
def test_marshal_load_ivar

18
test/ruby/test_module.rb
View file

@ -636,15 +636,15 @@ class TestModule < Test::Unit::TestCase
def bar; end
end
m.freeze
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
m.module_eval do
def foo; end
end
end
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
m.__send__ :private, :bar
end
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
m.private_class_method :baz
end
end
@ -949,7 +949,7 @@ class TestModule < Test::Unit::TestCase
def test_frozen_module
m = Module.new
m.freeze
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
m.instance_eval { undef_method(:foo) }
end
end
@ -957,7 +957,7 @@ class TestModule < Test::Unit::TestCase
def test_frozen_class
c = Class.new
c.freeze
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
c.instance_eval { undef_method(:foo) }
end
end
@ -967,7 +967,7 @@ class TestModule < Test::Unit::TestCase
o = klass.new
c = class << o; self; end
c.freeze
assert_raise_with_message(RuntimeError, /frozen/) do
assert_raise_with_message(FrozenError, /frozen/) do
c.instance_eval { undef_method(:foo) }
end
klass.class_eval do
@ -2077,17 +2077,17 @@ class TestModule < Test::Unit::TestCase
bug11532 = '[ruby-core:70828] [Bug #11532]'
c = Class.new {const_set(:A, 1)}.freeze
assert_raise_with_message(RuntimeError, /frozen class/, bug11532) {
assert_raise_with_message(FrozenError, /frozen class/, bug11532) {
c.class_eval {private_constant :A}
}
c = Class.new {const_set(:A, 1); private_constant :A}.freeze
assert_raise_with_message(RuntimeError, /frozen class/, bug11532) {
assert_raise_with_message(FrozenError, /frozen class/, bug11532) {
c.class_eval {public_constant :A}
}
c = Class.new {const_set(:A, 1)}.freeze
assert_raise_with_message(RuntimeError, /frozen class/, bug11532) {
assert_raise_with_message(FrozenError, /frozen class/, bug11532) {
c.class_eval {deprecate_constant :A}
}
end

12
test/ruby/test_object.rb
View file

@ -99,12 +99,12 @@ class TestObject < Test::Unit::TestCase
def test_taint_frozen_obj
o = Object.new
o.freeze
assert_raise(RuntimeError) { o.taint }
assert_raise(FrozenError) { o.taint }
o = Object.new
o.taint
o.freeze
assert_raise(RuntimeError) { o.untaint }
assert_raise(FrozenError) { o.untaint }
end
def test_freeze_immediate
@ -123,7 +123,7 @@ class TestObject < Test::Unit::TestCase
attr_accessor :foo
}
obj = klass.new.freeze
assert_raise_with_message(RuntimeError, /#{name}/) {
assert_raise_with_message(FrozenError, /#{name}/) {
obj.foo = 1
}
end
@ -399,7 +399,7 @@ class TestObject < Test::Unit::TestCase
def test_remove_method
c = Class.new
c.freeze
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
c.instance_eval { remove_method(:foo) }
end
@ -807,7 +807,7 @@ class TestObject < Test::Unit::TestCase
class<<x;self;end.class_eval {define_method(:to_s) {name}}
assert_same(name, x.to_s)
assert_not_predicate(name, :tainted?)
assert_raise(RuntimeError) {name.taint}
assert_raise(FrozenError) {name.taint}
assert_equal("X", [x].join(""))
assert_not_predicate(name, :tainted?)
assert_not_predicate(eval('"X".freeze'), :tainted?)
@ -899,7 +899,7 @@ class TestObject < Test::Unit::TestCase
b = yield
assert_nothing_raised("copy") {a.instance_eval {initialize_copy(b)}}
c = a.dup.freeze
assert_raise(RuntimeError, "frozen") {c.instance_eval {initialize_copy(b)}}
assert_raise(FrozenError, "frozen") {c.instance_eval {initialize_copy(b)}}
d = a.dup.trust
[a, b, c, d]
end

2
test/ruby/test_pack.rb
View file

@ -821,7 +821,7 @@ EXPECTED
def test_pack_with_buffer
buf = String.new(capacity: 100)
assert_raise_with_message(RuntimeError, /frozen/) {
assert_raise_with_message(FrozenError, /frozen/) {
[0xDEAD_BEEF].pack('N', buffer: 'foo'.freeze)
}
assert_raise_with_message(TypeError, /must be String/) {

4
test/ruby/test_rand.rb
View file

@ -507,7 +507,7 @@ END
def test_initialize_frozen
r = Random.new(0)
r.freeze
assert_raise(RuntimeError, '[Bug #6540]') do
assert_raise(FrozenError, '[Bug #6540]') do
r.__send__(:initialize, r)
end
end
@ -516,7 +516,7 @@ END
r = Random.new(0)
d = r.__send__(:marshal_dump)
r.freeze
assert_raise(RuntimeError, '[Bug #6540]') do
assert_raise(FrozenError, '[Bug #6540]') do
r.__send__(:marshal_load, d)
end
end

2
test/ruby/test_range.rb
View file

@ -22,7 +22,7 @@ class TestRange < Test::Unit::TestCase
def test_frozen_initialize
r = Range.allocate
r.freeze
assert_raise(RuntimeError){r.__send__(:initialize, 1, 2)}
assert_raise(FrozenError){r.__send__(:initialize, 1, 2)}
end
def test_range_string

2
test/ruby/test_rubyoptions.rb
View file

@ -928,7 +928,7 @@ class TestRubyOptions < Test::Unit::TestCase
def test_frozen_string_literal_debug
with_debug_pat = /created at/
wo_debug_pat = /can\'t modify frozen String \(RuntimeError\)\n\z/
wo_debug_pat = /can\'t modify frozen String \(FrozenError\)\n\z/
frozen = [
["--enable-frozen-string-literal", true],
["--disable-frozen-string-literal", false],

34
test/ruby/test_string.rb
View file

@ -62,12 +62,12 @@ class TestString < Test::Unit::TestCase
def test_initialize
str = S("").freeze
assert_equal("", str.__send__(:initialize))
assert_raise(RuntimeError){ str.__send__(:initialize, 'abc') }
assert_raise(RuntimeError){ str.__send__(:initialize, capacity: 1000) }
assert_raise(RuntimeError){ str.__send__(:initialize, 'abc', capacity: 1000) }
assert_raise(RuntimeError){ str.__send__(:initialize, encoding: 'euc-jp') }
assert_raise(RuntimeError){ str.__send__(:initialize, 'abc', encoding: 'euc-jp') }
assert_raise(RuntimeError){ str.__send__(:initialize, 'abc', capacity: 1000, encoding: 'euc-jp') }
assert_raise(FrozenError){ str.__send__(:initialize, 'abc') }
assert_raise(FrozenError){ str.__send__(:initialize, capacity: 1000) }
assert_raise(FrozenError){ str.__send__(:initialize, 'abc', capacity: 1000) }
assert_raise(FrozenError){ str.__send__(:initialize, encoding: 'euc-jp') }
assert_raise(FrozenError){ str.__send__(:initialize, 'abc', encoding: 'euc-jp') }
assert_raise(FrozenError){ str.__send__(:initialize, 'abc', capacity: 1000, encoding: 'euc-jp') }
end
def test_initialize_nonstring
@ -491,7 +491,7 @@ CODE
assert_equal(S("a").hash, S("a\u0101").chomp!(S("\u0101")).hash, '[ruby-core:22414]')
s = S("").freeze
assert_raise_with_message(RuntimeError, /frozen/) {s.chomp!}
assert_raise_with_message(FrozenError, /frozen/) {s.chomp!}
s = S("ax")
o = Struct.new(:s).new(s)
@ -499,7 +499,7 @@ CODE
s.freeze
"x"
end
assert_raise_with_message(RuntimeError, /frozen/) {s.chomp!(o)}
assert_raise_with_message(FrozenError, /frozen/) {s.chomp!(o)}
s = S("hello")
assert_equal("hel", s.chomp!('lo'))
@ -617,7 +617,7 @@ CODE
expected = S("\u0300".encode(Encoding::UTF_16LE))
assert_equal(expected, result, bug7090)
assert_raise(TypeError) { 'foo' << :foo }
assert_raise(RuntimeError) { 'foo'.freeze.concat('bar') }
assert_raise(FrozenError) { 'foo'.freeze.concat('bar') }
end
def test_concat_literals
@ -1367,10 +1367,10 @@ CODE
assert_equal(s2, s)
fs = "".freeze
assert_raise(RuntimeError) { fs.replace("a") }
assert_raise(RuntimeError) { fs.replace(fs) }
assert_raise(FrozenError) { fs.replace("a") }
assert_raise(FrozenError) { fs.replace(fs) }
assert_raise(ArgumentError) { fs.replace() }
assert_raise(RuntimeError) { fs.replace(42) }
assert_raise(FrozenError) { fs.replace(42) }
end
def test_reverse
@ -2272,7 +2272,7 @@ CODE
end
def test_frozen_check
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
s = ""
s.sub!(/\A/) { s.freeze; "zzz" }
}
@ -2710,7 +2710,7 @@ CODE
assert_equal("bba", s)
s = S("ax").freeze
assert_raise_with_message(RuntimeError, /frozen/) {s.delete_prefix!("a")}
assert_raise_with_message(FrozenError, /frozen/) {s.delete_prefix!("a")}
s = S("ax")
o = Struct.new(:s).new(s)
@ -2718,7 +2718,7 @@ CODE
s.freeze
"a"
end
assert_raise_with_message(RuntimeError, /frozen/) {s.delete_prefix!(o)}
assert_raise_with_message(FrozenError, /frozen/) {s.delete_prefix!(o)}
end
def test_delete_suffix
@ -2778,7 +2778,7 @@ CODE
assert_raise(TypeError) { 'hello'.delete_suffix!(/hel/) }
s = S("hello").freeze
assert_raise_with_message(RuntimeError, /frozen/) {s.delete_suffix!('lo')}
assert_raise_with_message(FrozenError, /frozen/) {s.delete_suffix!('lo')}
s = S("ax")
o = Struct.new(:s).new(s)
@ -2786,7 +2786,7 @@ CODE
s.freeze
"x"
end
assert_raise_with_message(RuntimeError, /frozen/) {s.delete_suffix!(o)}
assert_raise_with_message(FrozenError, /frozen/) {s.delete_suffix!(o)}
s = S("hello")
assert_equal("hel", s.delete_suffix!('lo'))

4
test/ruby/test_thread.rb
View file

@ -102,7 +102,7 @@ class TestThread < Test::Unit::TestCase
def test_thread_variable_frozen
t = Thread.new { }.join
t.freeze
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
t.thread_variable_set(:foo, "bar")
end
end
@ -547,7 +547,7 @@ class TestThread < Test::Unit::TestCase
end
def test_thread_local_security
assert_raise(RuntimeError) do
assert_raise(FrozenError) do
Thread.new do
Thread.current[:foo] = :bar
Thread.current.freeze

4
test/ruby/test_transcode.rb
View file

@ -13,8 +13,8 @@ class TestTranscode < Test::Unit::TestCase
assert_raise(Encoding::UndefinedConversionError) { "\x80".encode('utf-8','ASCII-8BIT') }
assert_raise(Encoding::InvalidByteSequenceError) { "\x80".encode('utf-8','US-ASCII') }
assert_raise(Encoding::UndefinedConversionError) { "\xA5".encode('utf-8','iso-8859-3') }
assert_raise(RuntimeError) { 'hello'.freeze.encode!('iso-8859-1') }
assert_raise(RuntimeError) { '\u3053\u3093\u306b\u3061\u306f'.freeze.encode!('iso-8859-1') } # こんにちは
assert_raise(FrozenError) { 'hello'.freeze.encode!('iso-8859-1') }
assert_raise(FrozenError) { '\u3053\u3093\u306b\u3061\u306f'.freeze.encode!('iso-8859-1') } # こんにちは
end
def test_arguments

4
test/ruby/test_variable.rb
View file

@ -137,14 +137,14 @@ class TestVariable < Test::Unit::TestCase
assert_empty v.instance_variables
msg = "can't modify frozen #{v.class}"
assert_raise_with_message(RuntimeError, msg) do
assert_raise_with_message(FrozenError, msg) do
v.instance_variable_set(:@foo, :bar)
end
assert_nil EnvUtil.suppress_warning {v.instance_variable_get(:@foo)}
assert_not_send([v, :instance_variable_defined?, :@foo])
assert_raise_with_message(RuntimeError, msg) do
assert_raise_with_message(FrozenError, msg) do
v.remove_instance_variable(:@foo)
end
end

6
test/stringio/test_stringio.rb
View file

@ -722,9 +722,9 @@ class TestStringIO < Test::Unit::TestCase
s = StringIO.new
s.freeze
bug = '[ruby-core:33648]'
assert_raise(RuntimeError, bug) {s.puts("foo")}
assert_raise(RuntimeError, bug) {s.string = "foo"}
assert_raise(RuntimeError, bug) {s.reopen("")}
assert_raise(FrozenError, bug) {s.puts("foo")}
assert_raise(FrozenError, bug) {s.string = "foo"}
assert_raise(FrozenError, bug) {s.reopen("")}
end
def test_frozen_string

4
test/test_delegate.rb
View file

@ -100,7 +100,7 @@ class TestDelegateClass < Test::Unit::TestCase
a = [42, :hello].freeze
d = SimpleDelegator.new(a)
assert_nothing_raised(bug2679) {d.dup[0] += 1}
assert_raise(RuntimeError) {d.clone[0] += 1}
assert_raise(FrozenError) {d.clone[0] += 1}
d.freeze
assert(d.clone.frozen?)
assert(!d.dup.frozen?)
@ -109,7 +109,7 @@ class TestDelegateClass < Test::Unit::TestCase
def test_frozen
d = SimpleDelegator.new([1, :foo])
d.freeze
assert_raise(RuntimeError, '[ruby-dev:40314]#1') {d.__setobj__("foo")}
assert_raise(FrozenError, '[ruby-dev:40314]#1') {d.__setobj__("foo")}
assert_equal([1, :foo], d)
end

8
test/test_set.rb
View file

@ -693,7 +693,7 @@ class TC_Set < Test::Unit::TestCase
set << 4
assert_same orig, set.freeze
assert_equal true, set.frozen?
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
set << 5
}
assert_equal 4, set.size
@ -716,7 +716,7 @@ class TC_Set < Test::Unit::TestCase
set2 = set1.clone
assert_predicate set2, :frozen?
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
set2.add 5
}
end
@ -849,7 +849,7 @@ class TC_SortedSet < Test::Unit::TestCase
set << 4
assert_same orig, set.freeze
assert_equal true, set.frozen?
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
set << 5
}
assert_equal 4, set.size
@ -877,7 +877,7 @@ class TC_SortedSet < Test::Unit::TestCase
set2 = set1.clone
assert_predicate set2, :frozen?
assert_raise(RuntimeError) {
assert_raise(FrozenError) {
set2.add 5
}
end