1 files changed, 94 insertions, 77 deletions
diff --git a/spec/ruby/core/marshal/dump_spec.rb b/spec/ruby/core/marshal/dump_spec.rb
index cc5337b50e..9bbb7809af 100644
--- a/spec/ruby/core/marshal/dump_spec.rb
+++ b/spec/ruby/core/marshal/dump_spec.rb
@@ -1,4 +1,4 @@
-# -*- encoding: binary -*-
+# encoding: binary
 require_relative '../../spec_helper'
 require_relative 'fixtures/classes'
 require_relative 'fixtures/marshal_data'
@@ -116,7 +116,7 @@ describe "Marshal.dump" do
     end
 
     it "raises TypeError if an Object is an instance of an anonymous class" do
-      -> { Marshal.dump(Class.new(UserMarshal).new) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(Class.new(UserMarshal).new) }.should.raise(TypeError, /can't dump anonymous class/)
     end
 
     it "uses object links for objects repeatedly dumped" do
@@ -157,11 +157,11 @@ describe "Marshal.dump" do
     it "raises a TypeError if _dump returns a non-string" do
       m = mock("marshaled")
       m.should_receive(:_dump).and_return(0)
-      -> { Marshal.dump(m) }.should raise_error(TypeError)
+      -> { Marshal.dump(m) }.should.raise(TypeError)
     end
 
     it "raises TypeError if an Object is an instance of an anonymous class" do
-      -> { Marshal.dump(Class.new(UserDefined).new) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(Class.new(UserDefined).new) }.should.raise(TypeError, /can't dump anonymous class/)
     end
 
     it "favors marshal_dump over _dump" do
@@ -231,9 +231,12 @@ describe "Marshal.dump" do
       Marshal.dump(MarshalSpec::ClassWithOverriddenName).should == "\x04\bc)MarshalSpec::ClassWithOverriddenName"
     end
 
-    it "dumps a class with multibyte characters in name" do
-      source_object = eval("MarshalSpec::MultibyteぁあぃいClass".dup.force_encoding(Encoding::UTF_8))
-      Marshal.dump(source_object).should == "\x04\bc,MarshalSpec::Multibyte\xE3\x81\x81\xE3\x81\x82\xE3\x81\x83\xE3\x81\x84Class"
+    ruby_version_is "4.0" do
+      it "dumps a class with multibyte characters in name" do
+        source_object = eval("MarshalSpec::MultibyteぁあぃいClass".dup.force_encoding(Encoding::UTF_8))
+        Marshal.dump(source_object).should == "\x04\bIc,MarshalSpec::Multibyte\xE3\x81\x81\xE3\x81\x82\xE3\x81\x83\xE3\x81\x84Class\x06:\x06ET"
+        Marshal.load(Marshal.dump(source_object)) == source_object
+      end
     end
 
     it "uses object links for objects repeatedly dumped" do
@@ -241,11 +244,11 @@ describe "Marshal.dump" do
     end
 
     it "raises TypeError with an anonymous Class" do
-      -> { Marshal.dump(Class.new) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(Class.new) }.should.raise(TypeError, /can't dump anonymous class/)
     end
 
     it "raises TypeError with a singleton Class" do
-      -> { Marshal.dump(class << self; self end) }.should raise_error(TypeError)
+      -> { Marshal.dump(class << self; self end) }.should.raise(TypeError)
     end
   end
 
@@ -258,9 +261,12 @@ describe "Marshal.dump" do
       Marshal.dump(MarshalSpec::ModuleWithOverriddenName).should == "\x04\bc*MarshalSpec::ModuleWithOverriddenName"
     end
 
-    it "dumps a module with multibyte characters in name" do
-      source_object = eval("MarshalSpec::MultibyteけげこごModule".dup.force_encoding(Encoding::UTF_8))
-      Marshal.dump(source_object).should == "\x04\bm-MarshalSpec::Multibyte\xE3\x81\x91\xE3\x81\x92\xE3\x81\x93\xE3\x81\x94Module"
+    ruby_version_is "4.0" do
+      it "dumps a module with multibyte characters in name" do
+        source_object = eval("MarshalSpec::MultibyteけげこごModule".dup.force_encoding(Encoding::UTF_8))
+        Marshal.dump(source_object).should == "\x04\bIm-MarshalSpec::Multibyte\xE3\x81\x91\xE3\x81\x92\xE3\x81\x93\xE3\x81\x94Module\x06:\x06ET"
+        Marshal.load(Marshal.dump(source_object)) == source_object
+      end
     end
 
     it "uses object links for objects repeatedly dumped" do
@@ -268,7 +274,7 @@ describe "Marshal.dump" do
     end
 
     it "raises TypeError with an anonymous Module" do
-      -> { Marshal.dump(Module.new) }.should raise_error(TypeError, /can't dump anonymous module/)
+      -> { Marshal.dump(Module.new) }.should.raise(TypeError, /can't dump anonymous module/)
     end
   end
 
@@ -361,30 +367,28 @@ describe "Marshal.dump" do
     end
   end
 
-  ruby_version_is "3.2" do
-    describe "with a Data" do
-      it "dumps a Data" do
-        Marshal.dump(MarshalSpec::DataSpec::Measure.new(100, 'km')).should == "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
-      end
+  describe "with a Data" do
+    it "dumps a Data" do
+      Marshal.dump(MarshalSpec::DataSpec::Measure.new(100, 'km')).should == "\x04\bS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm"
+    end
 
-      it "dumps an extended Data" do
-        obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")
-        Marshal.dump(obj).should == "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"
-      end
+    it "dumps an extended Data" do
+      obj = MarshalSpec::DataSpec::MeasureExtended.new(100, "km")
+      Marshal.dump(obj).should == "\x04\bS:+MarshalSpec::DataSpec::MeasureExtended\a:\vamountii:\tunit\"\akm"
+    end
 
-      it "ignores overridden name method" do
-        obj = MarshalSpec::DataSpec::MeasureWithOverriddenName.new(100, "km")
-        Marshal.dump(obj).should == "\x04\bS:5MarshalSpec::DataSpec::MeasureWithOverriddenName\a:\vamountii:\tunit\"\akm"
-      end
+    it "ignores overridden name method" do
+      obj = MarshalSpec::DataSpec::MeasureWithOverriddenName.new(100, "km")
+      Marshal.dump(obj).should == "\x04\bS:5MarshalSpec::DataSpec::MeasureWithOverriddenName\a:\vamountii:\tunit\"\akm"
+    end
 
-      it "uses object links for objects repeatedly dumped" do
-        d = MarshalSpec::DataSpec::Measure.new(100, 'km')
-        Marshal.dump([d, d]).should == "\x04\b[\aS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm@\x06" # @\x06 is a link to the object
-      end
+    it "uses object links for objects repeatedly dumped" do
+      d = MarshalSpec::DataSpec::Measure.new(100, 'km')
+      Marshal.dump([d, d]).should == "\x04\b[\aS:#MarshalSpec::DataSpec::Measure\a:\vamountii:\tunit\"\akm@\x06" # @\x06 is a link to the object
+    end
 
-      it "raises TypeError with an anonymous Struct" do
-        -> { Marshal.dump(Data.define(:a).new(1)) }.should raise_error(TypeError, /can't dump anonymous class/)
-      end
+    it "raises TypeError with an anonymous Struct" do
+      -> { Marshal.dump(Data.define(:a).new(1)) }.should.raise(TypeError, /can't dump anonymous class/)
     end
   end
 
@@ -469,14 +473,26 @@ describe "Marshal.dump" do
       Marshal.dump(//im).should == "\x04\bI/\x00\x05\x06:\x06EF"
     end
 
-    it "dumps a Regexp with instance variables" do
-      o = Regexp.new("")
+    it "dumps a Regexp subclass with instance variables" do
+      o = UserRegexp.new("")
       o.instance_variable_set(:@ivar, :ivar)
-      Marshal.dump(o).should == "\x04\bI/\x00\x00\a:\x06EF:\n@ivar:\tivar"
+      Marshal.dump(o).should == "\x04\bIC:\x0FUserRegexp/\x00\x00\a:\x06EF:\n@ivar:\tivar"
     end
 
-    it "dumps an extended Regexp" do
-      Marshal.dump(Regexp.new("").extend(Meths)).should == "\x04\bIe:\nMeths/\x00\x00\x06:\x06EF"
+    it "dumps an extended Regexp subclass" do
+      Marshal.dump(UserRegexp.new("").extend(Meths)).should == "\x04\bIe:\nMethsC:\x0FUserRegexp/\x00\x00\x06:\x06EF"
+    end
+
+    ruby_version_is ""..."4.1" do
+      it "dumps a Regexp with instance variables" do
+        o = Regexp.new("")
+        o.instance_variable_set(:@ivar, :ivar)
+        Marshal.dump(o).should == "\x04\bI/\x00\x00\a:\x06EF:\n@ivar:\tivar"
+      end
+
+      it "dumps an extended Regexp" do
+        Marshal.dump(Regexp.new("").extend(Meths)).should == "\x04\bIe:\nMeths/\x00\x00\x06:\x06EF"
+      end
     end
 
     it "dumps a Regexp subclass" do
@@ -599,24 +615,22 @@ describe "Marshal.dump" do
       Marshal.dump(Hash.new(1)).should == "\004\b}\000i\006"
     end
 
-    ruby_version_is "3.1" do
-      it "dumps a Hash with compare_by_identity" do
-        h = {}
-        h.compare_by_identity
+    it "dumps a Hash with compare_by_identity" do
+      h = {}
+      h.compare_by_identity
 
-        Marshal.dump(h).should == "\004\bC:\tHash{\x00"
-      end
+      Marshal.dump(h).should == "\004\bC:\tHash{\x00"
+    end
 
-      it "dumps a Hash subclass with compare_by_identity" do
-        h = UserHash.new
-        h.compare_by_identity
+    it "dumps a Hash subclass with compare_by_identity" do
+      h = UserHash.new
+      h.compare_by_identity
 
-        Marshal.dump(h).should == "\x04\bC:\rUserHashC:\tHash{\x00"
-      end
+      Marshal.dump(h).should == "\x04\bC:\rUserHashC:\tHash{\x00"
     end
 
     it "raises a TypeError with hash having default proc" do
-      -> { Marshal.dump(Hash.new {}) }.should raise_error(TypeError, "can't dump hash with default proc")
+      -> { Marshal.dump(Hash.new {}) }.should.raise(TypeError, "can't dump hash with default proc")
     end
 
     it "dumps a Hash with instance variables" do
@@ -692,7 +706,7 @@ describe "Marshal.dump" do
     end
 
     it "raises TypeError with an anonymous Struct" do
-      -> { Marshal.dump(Struct.new(:a).new(1)) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(Struct.new(:a).new(1)) }.should.raise(TypeError, /can't dump anonymous class/)
     end
 
     it "adds instance variables after the object itself into the objects table" do
@@ -751,7 +765,7 @@ describe "Marshal.dump" do
       def obj.foo; end
       -> {
         Marshal.dump(obj)
-      }.should raise_error(TypeError, "singleton can't be dumped")
+      }.should.raise(TypeError, "singleton can't be dumped")
     end
 
     it "raises TypeError if an Object has a singleton class and singleton instance variables" do
@@ -762,14 +776,14 @@ describe "Marshal.dump" do
 
       -> {
         Marshal.dump(obj)
-      }.should raise_error(TypeError, "singleton can't be dumped")
+      }.should.raise(TypeError, "singleton can't be dumped")
     end
 
     it "raises TypeError if an Object is an instance of an anonymous class" do
       anonymous_class = Class.new
       obj = anonymous_class.new
 
-      -> { Marshal.dump(obj) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(obj) }.should.raise(TypeError, /can't dump anonymous class/)
     end
 
     it "raises TypeError if an Object extends an anonymous module" do
@@ -777,7 +791,7 @@ describe "Marshal.dump" do
       obj = Object.new
       obj.extend(anonymous_module)
 
-      -> { Marshal.dump(obj) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(obj) }.should.raise(TypeError, /can't dump anonymous class/)
     end
 
     it "dumps a BasicObject subclass if it defines respond_to?" do
@@ -833,7 +847,7 @@ describe "Marshal.dump" do
     end
 
     it "raises TypeError with an anonymous Range subclass" do
-      -> { Marshal.dump(Class.new(Range).new(1, 2)) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(Class.new(Range).new(1, 2)) }.should.raise(TypeError, /can't dump anonymous class/)
     end
   end
 
@@ -863,7 +877,7 @@ describe "Marshal.dump" do
         base = "\x04\bIu:\tTime\r#{@t_dump}\a"
         offset = ":\voffseti\x020*"
         zone = ":\tzoneI\"\bAST\x06:\x06EF" # Last is 'F' (US-ASCII)
-        [ "#{base}#{offset}#{zone}", "#{base}#{zone}#{offset}" ].should include(dump)
+        [ "#{base}#{offset}#{zone}", "#{base}#{zone}#{offset}" ].should.include?(dump)
       end
     end
 
@@ -875,12 +889,15 @@ describe "Marshal.dump" do
 
     it "ignores overridden name method" do
       obj = MarshalSpec::TimeWithOverriddenName.new
-      Marshal.dump(obj).should include("MarshalSpec::TimeWithOverriddenName")
+      Marshal.dump(obj).should.include?("MarshalSpec::TimeWithOverriddenName")
     end
 
-    it "dumps a Time subclass with multibyte characters in name" do
-      source_object = eval("MarshalSpec::MultibyteぁあぃいTime".dup.force_encoding(Encoding::UTF_8))
-      Marshal.dump(source_object).should == "\x04\bc+MarshalSpec::Multibyte\xE3\x81\x81\xE3\x81\x82\xE3\x81\x83\xE3\x81\x84Time"
+    ruby_version_is "4.0" do
+      it "dumps a Time subclass with multibyte characters in name" do
+        source_object = eval("MarshalSpec::MultibyteぁあぃいTime".dup.force_encoding(Encoding::UTF_8))
+        Marshal.dump(source_object).should == "\x04\bIc+MarshalSpec::Multibyte\xE3\x81\x81\xE3\x81\x82\xE3\x81\x83\xE3\x81\x84Time\x06:\x06ET"
+        Marshal.load(Marshal.dump(source_object)) == source_object
+      end
     end
 
     it "uses object links for objects repeatedly dumped" do
@@ -904,7 +921,7 @@ describe "Marshal.dump" do
     end
 
     it "raises TypeError with an anonymous Time subclass" do
-      -> { Marshal.dump(Class.new(Time).now) }.should raise_error(TypeError)
+      -> { Marshal.dump(Class.new(Time).now) }.should.raise(TypeError)
     end
   end
 
@@ -937,13 +954,13 @@ describe "Marshal.dump" do
         begin
           raise RuntimeError, "the consequence"
         rescue RuntimeError => e
-          e.cause.should equal(cause)
+          e.cause.should.equal?(cause)
           exc = e
         end
       end
 
       reloaded = Marshal.load(Marshal.dump(exc))
-      reloaded.cause.should be_an_instance_of(StandardError)
+      reloaded.cause.should.instance_of?(StandardError)
       reloaded.cause.message.should == "the cause"
     end
 
@@ -976,7 +993,7 @@ describe "Marshal.dump" do
       anonymous_class = Class.new(Exception)
       obj = anonymous_class.new
 
-      -> { Marshal.dump(obj) }.should raise_error(TypeError, /can't dump anonymous class/)
+      -> { Marshal.dump(obj) }.should.raise(TypeError, /can't dump anonymous class/)
     end
   end
 
@@ -997,10 +1014,10 @@ describe "Marshal.dump" do
 
   it "raises an ArgumentError when the recursion limit is exceeded" do
     h = {'one' => {'two' => {'three' => 0}}}
-    -> { Marshal.dump(h, 3) }.should raise_error(ArgumentError)
-    -> { Marshal.dump([h], 4) }.should raise_error(ArgumentError)
-    -> { Marshal.dump([], 0) }.should raise_error(ArgumentError)
-    -> { Marshal.dump([[[]]], 1) }.should raise_error(ArgumentError)
+    -> { Marshal.dump(h, 3) }.should.raise(ArgumentError)
+    -> { Marshal.dump([h], 4) }.should.raise(ArgumentError)
+    -> { Marshal.dump([], 0) }.should.raise(ArgumentError)
+    -> { Marshal.dump([[[]]], 1) }.should.raise(ArgumentError)
   end
 
   it "ignores the recursion limit if the limit is negative" do
@@ -1022,7 +1039,7 @@ describe "Marshal.dump" do
 
     it "raises an Error when the IO-Object does not respond to #write" do
       obj = mock('test')
-      -> { Marshal.dump("test", obj) }.should raise_error(TypeError)
+      -> { Marshal.dump("test", obj) }.should.raise(TypeError)
     end
 
 
@@ -1037,29 +1054,29 @@ describe "Marshal.dump" do
   describe "when passed a StringIO" do
     it "should raise an error" do
       require "stringio"
-      -> { Marshal.dump(StringIO.new) }.should raise_error(TypeError)
+      -> { Marshal.dump(StringIO.new) }.should.raise(TypeError)
     end
   end
 
   it "raises a TypeError if marshalling a Method instance" do
-    -> { Marshal.dump(Marshal.method(:dump)) }.should raise_error(TypeError)
+    -> { Marshal.dump(Marshal.method(:dump)) }.should.raise(TypeError)
   end
 
   it "raises a TypeError if marshalling a Proc" do
-    -> { Marshal.dump(proc {}) }.should raise_error(TypeError)
+    -> { Marshal.dump(proc {}) }.should.raise(TypeError)
   end
 
   it "raises a TypeError if dumping a IO/File instance" do
-    -> { Marshal.dump(STDIN) }.should raise_error(TypeError)
-    -> { File.open(__FILE__) { |f| Marshal.dump(f) } }.should raise_error(TypeError)
+    -> { Marshal.dump(STDIN) }.should.raise(TypeError)
+    -> { File.open(__FILE__) { |f| Marshal.dump(f) } }.should.raise(TypeError)
   end
 
   it "raises a TypeError if dumping a MatchData instance" do
-    -> { Marshal.dump(/(.)/.match("foo")) }.should raise_error(TypeError)
+    -> { Marshal.dump(/(.)/.match("foo")) }.should.raise(TypeError)
   end
 
   it "raises a TypeError if dumping a Mutex instance" do
     m = Mutex.new
-    -> { Marshal.dump(m) }.should raise_error(TypeError)
+    -> { Marshal.dump(m) }.should.raise(TypeError)
   end
 end