5 files changed, 123 insertions, 31 deletions
diff --git a/spec/ruby/core/method/shared/aliased_inspect.rb b/spec/ruby/core/method/shared/aliased_inspect.rb
new file mode 100644
index 0000000000..2a622c2f97
--- /dev/null
+++ b/spec/ruby/core/method/shared/aliased_inspect.rb
@@ -0,0 +1,31 @@
+describe :method_to_s_aliased, shared: true do
+  # @object converts a bound Method to either a Method (identity) or an
+  # UnboundMethod (-> meth { meth.unbind }), so these expectations cover both
+  # Method#to_s/#inspect and UnboundMethod#to_s/#inspect.
+
+  it "shows the original name in parentheses for an aliased method" do
+    klass = Class.new do
+      def original_method; end
+      alias_method :renamed_method, :original_method
+    end
+    @object.call(klass.new.method(:renamed_method)).send(@method).should.include? '#renamed_method(original_method)'
+  end
+
+  it "shows the source UnboundMethod's name in parentheses for a define_method'd method" do
+    klass = Class.new { define_method(:renamed_is_a?, ::Kernel.instance_method(:is_a?)) }
+    @object.call(klass.new.method(:renamed_is_a?)).send(@method).should.include? '#renamed_is_a?(is_a?)'
+  end
+
+  it "does not annotate a directly looked-up Kernel method with a shared internal name" do
+    @object.call(Object.new.method(:is_a?)).send(@method).should_not.include? '(kind_of?)'
+    @object.call(Object.new.method(:kind_of?)).send(@method).should_not.include? '(is_a?)'
+  end
+
+  it "shows the source name when aliasing a define_method'd Kernel method" do
+    klass = Class.new do
+      define_method(:my_is_a?, ::Kernel.instance_method(:is_a?))
+      alias_method :renamed_is_a?, :my_is_a?
+    end
+    @object.call(klass.new.method(:renamed_is_a?)).send(@method).should.include? '#renamed_is_a?(is_a?)'
+  end
+end
diff --git a/spec/ruby/core/method/shared/call.rb b/spec/ruby/core/method/shared/call.rb
index f26e373695..41ee2b06cb 100644
--- a/spec/ruby/core/method/shared/call.rb
+++ b/spec/ruby/core/method/shared/call.rb
@@ -11,10 +11,10 @@ describe :method_call, shared: true do
   it "raises an ArgumentError when given incorrect number of arguments" do
     -> {
       MethodSpecs::Methods.new.method(:two_req).send(@method, 1, 2, 3)
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
     -> {
       MethodSpecs::Methods.new.method(:two_req).send(@method, 1)
-    }.should raise_error(ArgumentError)
+    }.should.raise(ArgumentError)
   end
 
   describe "for a Method generated by respond_to_missing?" do
diff --git a/spec/ruby/core/method/shared/dup.rb b/spec/ruby/core/method/shared/dup.rb
new file mode 100644
index 0000000000..eee790890a
--- /dev/null
+++ b/spec/ruby/core/method/shared/dup.rb
@@ -0,0 +1,32 @@
+describe :method_dup, shared: true do
+  it "returns a copy of self" do
+    a = Object.new.method(:method)
+    b = a.send(@method)
+
+    a.should == b
+    a.should_not.equal?(b)
+  end
+
+  ruby_version_is "3.4" do
+    it "copies instance variables" do
+      method = Object.new.method(:method)
+      method.instance_variable_set(:@ivar, 1)
+      cl = method.send(@method)
+      cl.instance_variables.should == [:@ivar]
+    end
+
+    it "copies the finalizer" do
+      code = <<-'RUBY'
+        obj = Object.new.method(:method)
+
+        ObjectSpace.define_finalizer(obj, Proc.new { STDOUT.write "finalized\n" })
+
+        obj.clone
+
+        exit 0
+      RUBY
+
+      ruby_exe(code).lines.sort.should == ["finalized\n", "finalized\n"]
+    end
+  end
+end
diff --git a/spec/ruby/core/method/shared/eql.rb b/spec/ruby/core/method/shared/eql.rb
index 5c720cbac1..3c340202b7 100644
--- a/spec/ruby/core/method/shared/eql.rb
+++ b/spec/ruby/core/method/shared/eql.rb
@@ -12,54 +12,54 @@ describe :method_equal, shared: true do
   it "returns true if methods are the same" do
     m2 = @m.method(:foo)
 
-    @m_foo.send(@method, @m_foo).should be_true
-    @m_foo.send(@method, m2).should be_true
+    @m_foo.send(@method, @m_foo).should == true
+    @m_foo.send(@method, m2).should == true
   end
 
   it "returns true on aliased methods" do
     m_bar = @m.method(:bar)
 
-    m_bar.send(@method, @m_foo).should be_true
+    m_bar.send(@method, @m_foo).should == true
   end
 
   it "returns true if the two core methods are aliases" do
     s = "hello"
     a = s.method(:size)
     b = s.method(:length)
-    a.send(@method, b).should be_true
+    a.send(@method, b).should == true
   end
 
   it "returns false on a method which is neither aliased nor the same method" do
     m2 = @m.method(:zero)
 
-    @m_foo.send(@method, m2).should be_false
+    @m_foo.send(@method, m2).should == false
   end
 
   it "returns false for a method which is not bound to the same object" do
     m2_foo = @m2.method(:foo)
     a_baz = @a.method(:baz)
 
-    @m_foo.send(@method, m2_foo).should be_false
-    @m_foo.send(@method, a_baz).should be_false
+    @m_foo.send(@method, m2_foo).should == false
+    @m_foo.send(@method, a_baz).should == false
   end
 
   it "returns false if the two methods are bound to the same object but were defined independently" do
     m2 = @m.method(:same_as_foo)
-    @m_foo.send(@method, m2).should be_false
+    @m_foo.send(@method, m2).should == false
   end
 
   it "returns true if a method was defined using the other one" do
     MethodSpecs::Methods.send :define_method, :defined_foo, MethodSpecs::Methods.instance_method(:foo)
     m2 = @m.method(:defined_foo)
-    @m_foo.send(@method, m2).should be_true
+    @m_foo.send(@method, m2).should == true
   end
 
   it "returns false if comparing a method defined via define_method and def" do
     defn = @m.method(:zero)
     defined = @m.method(:zero_defined_method)
 
-    defn.send(@method, defined).should be_false
-    defined.send(@method, defn).should be_false
+    defn.send(@method, defined).should == false
+    defined.send(@method, defn).should == false
   end
 
   describe 'missing methods' do
@@ -68,8 +68,8 @@ describe :method_equal, shared: true do
       miss1bis = @m.method(:handled_via_method_missing)
       miss2 = @m.method(:also_handled)
 
-      miss1.send(@method, miss1bis).should be_true
-      miss1.send(@method, miss2).should be_false
+      miss1.send(@method, miss1bis).should == true
+      miss1.send(@method, miss2).should == false
     end
 
     it 'calls respond_to_missing? with true to include private methods' do
@@ -81,14 +81,14 @@ describe :method_equal, shared: true do
   it "returns false if the two methods are bound to different objects, have the same names, and identical bodies" do
     a = MethodSpecs::Eql.instance_method(:same_body)
     b = MethodSpecs::Eql2.instance_method(:same_body)
-    a.send(@method, b).should be_false
+    a.send(@method, b).should == false
   end
 
   it "returns false if the argument is not a Method object" do
-    String.instance_method(:size).send(@method, 7).should be_false
+    String.instance_method(:size).send(@method, 7).should == false
   end
 
   it "returns false if the argument is an unbound version of self" do
-    method(:load).send(@method, method(:load).unbind).should be_false
+    method(:load).send(@method, method(:load).unbind).should == false
   end
 end
diff --git a/spec/ruby/core/method/shared/to_s.rb b/spec/ruby/core/method/shared/to_s.rb
index 7666322936..bfb58e6896 100644
--- a/spec/ruby/core/method/shared/to_s.rb
+++ b/spec/ruby/core/method/shared/to_s.rb
@@ -4,16 +4,16 @@ require_relative '../fixtures/classes'
 describe :method_to_s, shared: true do
   before :each do
     @m = MethodSpecs::MySub.new.method :bar
-    @string = @m.send(@method).sub(/0x\w+/, '0xXXXXXX')
+    @string = @m.send(@method)
   end
 
   it "returns a String" do
-    @m.send(@method).should be_kind_of(String)
+    @m.send(@method).should.is_a?(String)
   end
 
   it "returns a String for methods defined with attr_accessor" do
     m = MethodSpecs::Methods.new.method :attr
-    m.send(@method).should be_kind_of(String)
+    m.send(@method).should.is_a?(String)
   end
 
   it "returns a String containing 'Method'" do
@@ -24,6 +24,19 @@ describe :method_to_s, shared: true do
     @string.should =~ /\#bar/
   end
 
+  it "returns a String containing method arguments" do
+    obj = MethodSpecs::Methods.new
+    obj.method(:zero).send(@method).should.include?("()")
+    obj.method(:one_req).send(@method).should.include?("(a)")
+    obj.method(:one_req_named).send(@method).should.include?("(a:)")
+    obj.method(:zero_with_block).send(@method).should.include?("(&blk)")
+    obj.method(:one_opt).send(@method).should.include?("(a=...)")
+    obj.method(:one_opt_named).send(@method).should.include?("(a: ...)")
+    obj.method(:zero_with_splat).send(@method).should.include?("(*a)")
+    obj.method(:zero_with_double_splat).send(@method).should.include?("(**a)")
+    obj.method(:one_req_one_opt_with_splat_and_block).send(@method).should.include?("(a, b=..., *c, &blk)")
+  end
+
   it "returns a String containing the Module the method is defined in" do
     @string.should =~ /MethodSpecs::MyMod/
   end
@@ -32,21 +45,37 @@ describe :method_to_s, shared: true do
     @string.should =~ /MethodSpecs::MySub/
   end
 
-  ruby_version_is '2.8' do
-    it "returns a String containing the Module containing the method if object has a singleton class but method is not defined in the singleton class" do
-      obj = MethodSpecs::MySub.new
-      obj.singleton_class
-      @m = obj.method(:bar)
-      @string = @m.send(@method).sub(/0x\w+/, '0xXXXXXX')
-      @string.should =~ /\A#<Method: MethodSpecs::MySub\(MethodSpecs::MyMod\)#bar\(\) /
-    end
+  it "returns a String including all details" do
+    @string.should.start_with? "#<Method: MethodSpecs::MySub(MethodSpecs::MyMod)#bar"
+  end
+
+  it "does not show the defining module if it is the same as the receiver class" do
+    MethodSpecs::A.new.method(:baz).send(@method).should.start_with? "#<Method: MethodSpecs::A#baz"
+  end
+
+  it "returns a String containing the Module containing the method if object has a singleton class but method is not defined in the singleton class" do
+    obj = MethodSpecs::MySub.new
+    obj.singleton_class
+    @m = obj.method(:bar)
+    @string = @m.send(@method)
+    @string.should.start_with? "#<Method: MethodSpecs::MySub(MethodSpecs::MyMod)#bar"
+
+    c = MethodSpecs::MySub.dup
+    m = Module.new{def bar; end}
+    c.extend(m)
+    @string = c.method(:bar).send(@method)
+    @string.should.start_with? "#<Method: #<Class:#{c.inspect}>(#{m.inspect})#bar"
   end
 
   it "returns a String containing the singleton class if method is defined in the singleton class" do
     obj = MethodSpecs::MySub.new
     def obj.bar; end
     @m = obj.method(:bar)
-    @string = @m.send(@method).sub(/0x\w+/, '0xXXXXXX')
-    @string.should =~ /\A#<Method: #<MethodSpecs::MySub:0xXXXXXX>\.bar/
+    @string = @m.send(@method).sub(/0x\h+/, '0xXXXXXX')
+    @string.should.start_with? "#<Method: #<MethodSpecs::MySub:0xXXXXXX>.bar"
+  end
+
+  it "shows the metaclass and the owner for a Module instance method retrieved from a class" do
+    String.method(:include).inspect.should.start_with?("#<Method: #<Class:String>(Module)#include")
   end
 end