1 files changed, 261 insertions, 58 deletions

diff --git a/spec/ruby/core/marshal/dump_spec.rb b/spec/ruby/core/marshal/dump_spec.rb
index a54a4c6735..0f77279a4f 100644
--- a/spec/ruby/core/marshal/dump_spec.rb
+++ b/spec/ruby/core/marshal/dump_spec.rb
@@ -1,5 +1,6 @@
 # -*- encoding: binary -*-
 require_relative '../../spec_helper'
+require_relative 'fixtures/classes'
 require_relative 'fixtures/marshal_data'
 
 describe "Marshal.dump" do
@@ -75,7 +76,7 @@ describe "Marshal.dump" do
     end
 
     it "dumps a binary encoded Symbol" do
-      s = "\u2192".force_encoding("binary").to_sym
+      s = "\u2192".dup.force_encoding("binary").to_sym
       Marshal.dump(s).should == "\x04\b:\b\xE2\x86\x92"
     end
 
@@ -84,8 +85,8 @@ describe "Marshal.dump" do
       symbol1 = "I:\t\xE2\x82\xACa\x06:\x06ET"
       symbol2 = "I:\t\xE2\x82\xACb\x06;\x06T"
       value = [
-        "€a".force_encoding(Encoding::UTF_8).to_sym,
-        "€b".force_encoding(Encoding::UTF_8).to_sym
+        "€a".dup.force_encoding(Encoding::UTF_8).to_sym,
+        "€b".dup.force_encoding(Encoding::UTF_8).to_sym
       ]
       Marshal.dump(value).should == "\x04\b[\a#{symbol1}#{symbol2}"
 
@@ -103,25 +104,76 @@ describe "Marshal.dump" do
       UserMarshal.should_not_receive(:name)
       Marshal.dump(UserMarshal.new)
     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/)
+    end
   end
 
   describe "with an object responding to #_dump" do
-    it "dumps the object returned by #marshal_dump" do
+    it "dumps the String returned by #_dump" do
       Marshal.dump(UserDefined.new).should == "\004\bu:\020UserDefined\022\004\b[\a:\nstuff;\000"
     end
 
+    it "dumps the String in non US-ASCII and non UTF-8 encoding" do
+      object = UserDefinedString.new("a".encode("windows-1251"))
+      Marshal.dump(object).should == "\x04\bIu:\x16UserDefinedString\x06a\x06:\rencoding\"\x11Windows-1251"
+    end
+
+    it "dumps the String in multibyte encoding" do
+      object = UserDefinedString.new("a".encode("utf-32le"))
+      Marshal.dump(object).should == "\x04\bIu:\x16UserDefinedString\ta\x00\x00\x00\x06:\rencoding\"\rUTF-32LE"
+    end
+
+    it "ignores overridden name method" do
+      obj = MarshalSpec::UserDefinedWithOverriddenName.new
+      Marshal.dump(obj).should == "\x04\bu:/MarshalSpec::UserDefinedWithOverriddenName\x12\x04\b[\a:\nstuff;\x00"
+    end
+
     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)
     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/)
+    end
+
     it "favors marshal_dump over _dump" do
       m = mock("marshaled")
       m.should_receive(:marshal_dump).and_return(0)
       m.should_not_receive(:_dump)
       Marshal.dump(m)
     end
+
+    it "indexes instance variables of a String returned by #_dump at first and then indexes the object itself" do
+      class MarshalSpec::M1::A
+        def _dump(level)
+          s = +"<dump>"
+          s.instance_variable_set(:@foo, "bar")
+          s
+        end
+      end
+
+      a = MarshalSpec::M1::A.new
+
+      # 0-based index of the object a = 2, that is encoded as \x07 and printed as "\a" character.
+      # Objects are serialized in the following order: Array, a, "bar".
+      # But they are indexed in different order: Array (index=0), "bar" (index=1), a (index=2)
+      # So the second occurenc of the object a is encoded as an index 2.
+      reference = "@\a"
+      Marshal.dump([a, a]).should == "\x04\b[\aIu:\x17MarshalSpec::M1::A\v<dump>\x06:\t@foo\"\bbar#{reference}"
+    end
+
+    describe "Core library classes with #_dump returning a String with instance variables" do
+      it "indexes instance variables and then a Time object itself" do
+        t = Time.utc(2022)
+        reference = "@\a"
+
+        Marshal.dump([t, t]).should == "\x04\b[\aIu:\tTime\r \x80\x1E\xC0\x00\x00\x00\x00\x06:\tzoneI\"\bUTC\x06:\x06EF#{reference}"
+      end
+    end
   end
 
   describe "with a Class" do
@@ -137,8 +189,17 @@ describe "Marshal.dump" do
       Marshal.dump(UserDefined::Nested).should == "\004\bc\030UserDefined::Nested"
     end
 
+    it "ignores overridden name method" 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"
+    end
+
     it "raises TypeError with an anonymous Class" do
-      -> { Marshal.dump(Class.new) }.should raise_error(TypeError)
+      -> { Marshal.dump(Class.new) }.should raise_error(TypeError, /can't dump anonymous class/)
     end
 
     it "raises TypeError with a singleton Class" do
@@ -151,8 +212,17 @@ describe "Marshal.dump" do
       Marshal.dump(Marshal).should == "\004\bm\fMarshal"
     end
 
+    it "ignores overridden name method" 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"
+    end
+
     it "raises TypeError with an anonymous Module" do
-      -> { Marshal.dump(Module.new) }.should raise_error(TypeError)
+      -> { Marshal.dump(Module.new) }.should raise_error(TypeError, /can't dump anonymous module/)
     end
   end
 
@@ -185,15 +255,41 @@ describe "Marshal.dump" do
         [Marshal, -2**64, "\004\bl-\n\000\000\000\000\000\000\000\000\001\000"],
       ].should be_computed_by(:dump)
     end
+
+    it "increases the object links counter" do
+      obj = Object.new
+      object_1_link = "\x06" # representing of (0-based) index=1 (by adding 5 for small Integers)
+      object_2_link = "\x07" # representing of index=2
+
+      # objects: Array, Object, Object
+      Marshal.dump([obj, obj]).should == "\x04\b[\ao:\vObject\x00@#{object_1_link}"
+
+      # objects: Array, Bignum, Object, Object
+      Marshal.dump([2**64, obj, obj]).should == "\x04\b[\bl+\n\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00o:\vObject\x00@#{object_2_link}"
+      Marshal.dump([2**48, obj, obj]).should == "\x04\b[\bl+\t\x00\x00\x00\x00\x00\x00\x01\x00o:\vObject\x00@#{object_2_link}"
+      Marshal.dump([2**32, obj, obj]).should == "\x04\b[\bl+\b\x00\x00\x00\x00\x01\x00o:\vObject\x00@#{object_2_link}"
+    end
+  end
+
+  describe "with a Rational" do
+    it "dumps a Rational" do
+      Marshal.dump(Rational(2, 3)).should == "\x04\bU:\rRational[\ai\ai\b"
+    end
+  end
+
+  describe "with a Complex" do
+    it "dumps a Complex" do
+      Marshal.dump(Complex(2, 3)).should == "\x04\bU:\fComplex[\ai\ai\b"
+    end
   end
 
   describe "with a String" do
     it "dumps a blank String" do
-      Marshal.dump("".force_encoding("binary")).should == "\004\b\"\000"
+      Marshal.dump("".dup.force_encoding("binary")).should == "\004\b\"\000"
     end
 
     it "dumps a short String" do
-      Marshal.dump("short".force_encoding("binary")).should == "\004\b\"\012short"
+      Marshal.dump("short".dup.force_encoding("binary")).should == "\004\b\"\012short"
     end
 
     it "dumps a long String" do
@@ -201,7 +297,7 @@ describe "Marshal.dump" do
     end
 
     it "dumps a String extended with a Module" do
-      Marshal.dump("".extend(Meths).force_encoding("binary")).should == "\004\be:\nMeths\"\000"
+      Marshal.dump("".dup.extend(Meths).force_encoding("binary")).should == "\004\be:\nMeths\"\000"
     end
 
     it "dumps a String subclass" do
@@ -212,24 +308,29 @@ describe "Marshal.dump" do
       Marshal.dump(UserString.new.extend(Meths).force_encoding("binary")).should == "\004\be:\nMethsC:\017UserString\"\000"
     end
 
+    it "ignores overridden name method when dumps a String subclass" do
+      obj = MarshalSpec::StringWithOverriddenName.new
+      Marshal.dump(obj).should == "\x04\bC:*MarshalSpec::StringWithOverriddenName\"\x00"
+    end
+
     it "dumps a String with instance variables" do
-      str = ""
+      str = +""
       str.instance_variable_set("@foo", "bar")
       Marshal.dump(str.force_encoding("binary")).should == "\x04\bI\"\x00\x06:\t@foo\"\bbar"
     end
 
     it "dumps a US-ASCII String" do
-      str = "abc".force_encoding("us-ascii")
+      str = "abc".dup.force_encoding("us-ascii")
       Marshal.dump(str).should == "\x04\bI\"\babc\x06:\x06EF"
     end
 
     it "dumps a UTF-8 String" do
-      str = "\x6d\xc3\xb6\x68\x72\x65".force_encoding("utf-8")
+      str = "\x6d\xc3\xb6\x68\x72\x65".dup.force_encoding("utf-8")
       Marshal.dump(str).should == "\x04\bI\"\vm\xC3\xB6hre\x06:\x06ET"
     end
 
     it "dumps a String in another encoding" do
-      str = "\x6d\x00\xf6\x00\x68\x00\x72\x00\x65\x00".force_encoding("utf-16le")
+      str = "\x6d\x00\xf6\x00\x68\x00\x72\x00\x65\x00".dup.force_encoding("utf-16le")
       result = "\x04\bI\"\x0Fm\x00\xF6\x00h\x00r\x00e\x00\x06:\rencoding\"\rUTF-16LE"
       Marshal.dump(str).should == result
     end
@@ -263,18 +364,46 @@ describe "Marshal.dump" do
     end
 
     it "dumps a binary Regexp" do
-      o = Regexp.new("".force_encoding("binary"), Regexp::FIXEDENCODING)
+      o = Regexp.new("".dup.force_encoding("binary"), Regexp::FIXEDENCODING)
       Marshal.dump(o).should == "\x04\b/\x00\x10"
     end
 
+    it "dumps an ascii-compatible Regexp" do
+      o = Regexp.new("a".encode("us-ascii"), Regexp::FIXEDENCODING)
+      Marshal.dump(o).should == "\x04\bI/\x06a\x10\x06:\x06EF"
+
+      o = Regexp.new("a".encode("us-ascii"))
+      Marshal.dump(o).should == "\x04\bI/\x06a\x00\x06:\x06EF"
+
+      o = Regexp.new("a".encode("windows-1251"), Regexp::FIXEDENCODING)
+      Marshal.dump(o).should == "\x04\bI/\x06a\x10\x06:\rencoding\"\x11Windows-1251"
+
+      o = Regexp.new("a".encode("windows-1251"))
+      Marshal.dump(o).should == "\x04\bI/\x06a\x00\x06:\x06EF"
+    end
+
     it "dumps a UTF-8 Regexp" do
-      o = Regexp.new("".force_encoding("utf-8"), Regexp::FIXEDENCODING)
+      o = Regexp.new("".dup.force_encoding("utf-8"), Regexp::FIXEDENCODING)
       Marshal.dump(o).should == "\x04\bI/\x00\x10\x06:\x06ET"
+
+      o = Regexp.new("a".dup.force_encoding("utf-8"), Regexp::FIXEDENCODING)
+      Marshal.dump(o).should == "\x04\bI/\x06a\x10\x06:\x06ET"
+
+      o = Regexp.new("\u3042".dup.force_encoding("utf-8"), Regexp::FIXEDENCODING)
+      Marshal.dump(o).should == "\x04\bI/\b\xE3\x81\x82\x10\x06:\x06ET"
     end
 
     it "dumps a Regexp in another encoding" do
-      o = Regexp.new("".force_encoding("utf-16le"), Regexp::FIXEDENCODING)
+      o = Regexp.new("".dup.force_encoding("utf-16le"), Regexp::FIXEDENCODING)
       Marshal.dump(o).should == "\x04\bI/\x00\x10\x06:\rencoding\"\rUTF-16LE"
+
+      o = Regexp.new("a".encode("utf-16le"), Regexp::FIXEDENCODING)
+      Marshal.dump(o).should == "\x04\bI/\aa\x00\x10\x06:\rencoding\"\rUTF-16LE"
+    end
+
+    it "ignores overridden name method when dumps a Regexp subclass" do
+      obj = MarshalSpec::RegexpWithOverriddenName.new("")
+      Marshal.dump(obj).should == "\x04\bIC:*MarshalSpec::RegexpWithOverriddenName/\x00\x00\x06:\x06EF"
     end
   end
 
@@ -306,6 +435,11 @@ describe "Marshal.dump" do
     it "dumps an extended Array" do
       Marshal.dump([].extend(Meths)).should == "\004\be:\nMeths[\000"
     end
+
+    it "ignores overridden name method when dumps an Array subclass" do
+      obj = MarshalSpec::ArrayWithOverriddenName.new
+      Marshal.dump(obj).should == "\x04\bC:)MarshalSpec::ArrayWithOverriddenName[\x00"
+    end
   end
 
   describe "with a Hash" do
@@ -313,6 +447,10 @@ describe "Marshal.dump" do
       Marshal.dump({}).should == "\004\b{\000"
     end
 
+    it "dumps a non-empty Hash" do
+      Marshal.dump({a: 1}).should == "\x04\b{\x06:\x06ai\x06"
+    end
+
     it "dumps a Hash subclass" do
       Marshal.dump(UserHash.new).should == "\004\bC:\rUserHash{\000"
     end
@@ -321,8 +459,24 @@ 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
+
+        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
+
+        Marshal.dump(h).should == "\x04\bC:\rUserHashC:\tHash{\x00"
+      end
+    end
+
     it "raises a TypeError with hash having default proc" do
-      -> { Marshal.dump(Hash.new {}) }.should raise_error(TypeError)
+      -> { Marshal.dump(Hash.new {}) }.should raise_error(TypeError, "can't dump hash with default proc")
     end
 
     it "dumps a Hash with instance variables" do
@@ -338,6 +492,11 @@ describe "Marshal.dump" do
     it "dumps an Hash subclass with a parameter to initialize" do
       Marshal.dump(UserHashInitParams.new(1)).should == "\004\bIC:\027UserHashInitParams{\000\006:\a@ai\006"
     end
+
+    it "ignores overridden name method when dumps a Hash subclass" do
+      obj = MarshalSpec::HashWithOverriddenName.new
+      Marshal.dump(obj).should == "\x04\bC:(MarshalSpec::HashWithOverriddenName{\x00"
+    end
   end
 
   describe "with a Struct" do
@@ -366,6 +525,15 @@ describe "Marshal.dump" do
       Marshal.dump(obj).should == "\004\be:\nMethsS:\025Struct::Extended\a:\006a[\a;\a\"\ahi:\006b[\a;\000@\a"
       Struct.send(:remove_const, :Extended)
     end
+
+    it "ignores overridden name method" do
+      obj = MarshalSpec::StructWithOverriddenName.new("member")
+      Marshal.dump(obj).should == "\x04\bS:*MarshalSpec::StructWithOverriddenName\x06:\x06a\"\vmember"
+    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/)
+    end
   end
 
   describe "with an Object" do
@@ -385,7 +553,7 @@ describe "Marshal.dump" do
 
     it "dumps an Object with a non-US-ASCII instance variable" do
       obj = Object.new
-      ivar = "@é".force_encoding(Encoding::UTF_8).to_sym
+      ivar = "@é".dup.force_encoding(Encoding::UTF_8).to_sym
       obj.instance_variable_set(ivar, 1)
       Marshal.dump(obj).should == "\x04\bo:\vObject\x06I:\b@\xC3\xA9\x06:\x06ETi\x06"
     end
@@ -397,13 +565,18 @@ describe "Marshal.dump" do
       Marshal.dump(obj).should == "\004\bo:\x0BObject\x00"
     end
 
-    it "dumps an Object if it has a singleton class but no singleton methods" do
+    it "dumps an Object if it has a singleton class but no singleton methods and no singleton instance variables" do
       obj = Object.new
       obj.singleton_class
       Marshal.dump(obj).should == "\004\bo:\x0BObject\x00"
     end
 
-    it "raises if an Object has a singleton class and singleton methods" do
+    it "ignores overridden name method" do
+      obj = MarshalSpec::ClassWithOverriddenName.new
+      Marshal.dump(obj).should == "\x04\bo:)MarshalSpec::ClassWithOverriddenName\x00"
+    end
+
+    it "raises TypeError if an Object has a singleton class and singleton methods" do
       obj = Object.new
       def obj.foo; end
       -> {
@@ -411,10 +584,45 @@ describe "Marshal.dump" do
       }.should raise_error(TypeError, "singleton can't be dumped")
     end
 
+    it "raises TypeError if an Object has a singleton class and singleton instance variables" do
+      obj = Object.new
+      class << obj
+        @v = 1
+      end
+
+      -> {
+        Marshal.dump(obj)
+      }.should raise_error(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/)
+    end
+
+    it "raises TypeError if an Object extends an anonymous module" do
+      anonymous_module = Module.new
+      obj = Object.new
+      obj.extend(anonymous_module)
+
+      -> { Marshal.dump(obj) }.should raise_error(TypeError, /can't dump anonymous class/)
+    end
+
     it "dumps a BasicObject subclass if it defines respond_to?" do
       obj = MarshalSpec::BasicObjectSubWithRespondToFalse.new
       Marshal.dump(obj).should == "\x04\bo:2MarshalSpec::BasicObjectSubWithRespondToFalse\x00"
     end
+
+    it "dumps without marshaling any attached finalizer" do
+      obj = Object.new
+      finalizer = Object.new
+      def finalizer.noop(_)
+      end
+      ObjectSpace.define_finalizer(obj, finalizer.method(:noop))
+      Marshal.load(Marshal.dump(obj)).class.should == Object
+    end
   end
 
   describe "with a Range" do
@@ -430,15 +638,8 @@ describe "Marshal.dump" do
       load.should == (1...2)
     end
 
-    ruby_version_is ""..."3.0" do
-      it "dumps a Range with extra instance variables" do
-        range = (1...3)
-        range.instance_variable_set :@foo, 42
-        dump = Marshal.dump(range)
-        load = Marshal.load(dump)
-        load.should == range
-        load.instance_variable_get(:@foo).should == 42
-      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/)
     end
   end
 
@@ -477,6 +678,20 @@ describe "Marshal.dump" do
       zone = ":\tzoneI\"\bUTC\x06:\x06EF" # Last is 'F' (US-ASCII)
       dump.should == "\x04\bIu:\tTime\r#{@utc_dump}\x06#{zone}"
     end
+
+    it "ignores overridden name method" do
+      obj = MarshalSpec::TimeWithOverriddenName.new
+      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"
+    end
+
+    it "raises TypeError with an anonymous Time subclass" do
+      -> { Marshal.dump(Class.new(Time).now) }.should raise_error(TypeError)
+    end
   end
 
   describe "with an Exception" do
@@ -517,6 +732,23 @@ describe "Marshal.dump" do
       reloaded.cause.should be_an_instance_of(StandardError)
       reloaded.cause.message.should == "the cause"
     end
+
+    # NoMethodError uses an exception formatter on TruffleRuby and computes a message lazily
+    it "dumps the message for the raised NoMethodError exception" do
+      begin
+        "".foo
+      rescue => e
+      end
+
+      Marshal.dump(e).should =~ /undefined method [`']foo' for ("":String|an instance of String)/
+    end
+
+    it "raises TypeError if an Object is an instance of an anonymous class" do
+      anonymous_class = Class.new(Exception)
+      obj = anonymous_class.new
+
+      -> { Marshal.dump(obj) }.should raise_error(TypeError, /can't dump anonymous class/)
+    end
   end
 
   it "dumps subsequent appearances of a symbol as a link" do
@@ -549,7 +781,6 @@ describe "Marshal.dump" do
   end
 
   describe "when passed an IO" do
-
     it "writes the serialized data to the IO-Object" do
       (obj = mock('test')).should_receive(:write).at_least(1)
       Marshal.dump("test", obj)
@@ -572,8 +803,6 @@ describe "Marshal.dump" do
       obj.should_receive(:binmode).at_least(1)
       Marshal.dump("test", obj)
     end
-
-
   end
 
   describe "when passed a StringIO" do
@@ -604,30 +833,4 @@ describe "Marshal.dump" do
     m = Mutex.new
     -> { Marshal.dump(m) }.should raise_error(TypeError)
   end
-
-  ruby_version_is ''...'2.7' do
-    it "returns an untainted string if object is untainted" do
-      Marshal.dump(Object.new).tainted?.should be_false
-    end
-
-    it "returns a tainted string if object is tainted" do
-      Marshal.dump(Object.new.taint).tainted?.should be_true
-    end
-
-    it "returns a tainted string if nested object is tainted" do
-      Marshal.dump([[Object.new.taint]]).tainted?.should be_true
-    end
-
-    it "returns a trusted string if object is trusted" do
-      Marshal.dump(Object.new).untrusted?.should be_false
-    end
-
-    it "returns an untrusted string if object is untrusted" do
-      Marshal.dump(Object.new.untrust).untrusted?.should be_true
-    end
-
-    it "returns an untrusted string if nested object is untrusted" do
-      Marshal.dump([[Object.new.untrust]]).untrusted?.should be_true
-    end
-  end
 end