1 files changed, 67 insertions, 64 deletions

diff --git a/spec/ruby/language/def_spec.rb b/spec/ruby/language/def_spec.rb
index eb44331bb5..82c89a0d08 100644
--- a/spec/ruby/language/def_spec.rb
+++ b/spec/ruby/language/def_spec.rb
@@ -14,11 +14,11 @@ end
 
 describe "Defining a method at the top-level" do
   it "defines it on Object with private visibility by default" do
-    Object.should have_private_instance_method(:some_toplevel_method, false)
+    Object.private_instance_methods(false).should.include?(:some_toplevel_method)
   end
 
   it "defines it on Object with public visibility after calling public" do
-    Object.should have_public_instance_method(:public_toplevel_method, false)
+    Object.public_instance_methods(false).should.include?(:public_toplevel_method)
   end
 end
 
@@ -28,7 +28,7 @@ describe "Defining an 'initialize' method" do
       def initialize
       end
     end
-    DefInitializeSpec.should have_private_instance_method(:initialize, false)
+    DefInitializeSpec.private_instance_methods(false).should.include?(:initialize)
   end
 end
 
@@ -38,7 +38,7 @@ describe "Defining an 'initialize_copy' method" do
       def initialize_copy
       end
     end
-    DefInitializeCopySpec.should have_private_instance_method(:initialize_copy, false)
+    DefInitializeCopySpec.private_instance_methods(false).should.include?(:initialize_copy)
   end
 end
 
@@ -48,7 +48,7 @@ describe "Defining an 'initialize_dup' method" do
       def initialize_dup
       end
     end
-    DefInitializeDupSpec.should have_private_instance_method(:initialize_dup, false)
+    DefInitializeDupSpec.private_instance_methods(false).should.include?(:initialize_dup)
   end
 end
 
@@ -58,7 +58,7 @@ describe "Defining an 'initialize_clone' method" do
       def initialize_clone
       end
     end
-    DefInitializeCloneSpec.should have_private_instance_method(:initialize_clone, false)
+    DefInitializeCloneSpec.private_instance_methods(false).should.include?(:initialize_clone)
   end
 end
 
@@ -68,7 +68,7 @@ describe "Defining a 'respond_to_missing?' method" do
       def respond_to_missing?
       end
     end
-    DefRespondToMissingPSpec.should have_private_instance_method(:respond_to_missing?, false)
+    DefRespondToMissingPSpec.private_instance_methods(false).should.include?(:respond_to_missing?)
   end
 end
 
@@ -82,12 +82,12 @@ end
 describe "An instance method" do
   it "raises an error with too few arguments" do
     def foo(a, b); end
-    -> { foo 1 }.should raise_error(ArgumentError, 'wrong number of arguments (given 1, expected 2)')
+    -> { foo 1 }.should.raise(ArgumentError, 'wrong number of arguments (given 1, expected 2)')
   end
 
   it "raises an error with too many arguments" do
     def foo(a); end
-    -> { foo 1, 2 }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
+    -> { foo 1, 2 }.should.raise(ArgumentError, 'wrong number of arguments (given 2, expected 1)')
   end
 
   it "raises FrozenError with the correct class name" do
@@ -96,8 +96,9 @@ describe "An instance method" do
         self.freeze
         def foo; end
       end
-    }.should raise_error(FrozenError) { |e|
-      e.message.should.start_with? "can't modify frozen module"
+    }.should.raise(FrozenError) { |e|
+      msg_class = ruby_version_is("4.0") ? "Module" : "module"
+      e.message.should == "can't modify frozen #{msg_class}: #{e.receiver}"
     }
 
     -> {
@@ -105,8 +106,9 @@ describe "An instance method" do
         self.freeze
         def foo; end
       end
-    }.should raise_error(FrozenError){ |e|
-      e.message.should.start_with? "can't modify frozen class"
+    }.should.raise(FrozenError){ |e|
+      msg_class = ruby_version_is("4.0") ? "Class" : "class"
+      e.message.should == "can't modify frozen #{msg_class}: #{e.receiver}"
     }
   end
 end
@@ -133,12 +135,12 @@ describe "An instance method definition with a splat" do
   end
 
   it "allows only a single * argument" do
-    -> { eval 'def foo(a, *b, *c); end' }.should raise_error(SyntaxError)
+    -> { eval 'def foo(a, *b, *c); end' }.should.raise(SyntaxError)
   end
 
   it "requires the presence of any arguments that precede the *" do
     def foo(a, b, *c); end
-    -> { foo 1 }.should raise_error(ArgumentError, 'wrong number of arguments (given 1, expected 2+)')
+    -> { foo 1 }.should.raise(ArgumentError, 'wrong number of arguments (given 1, expected 2+)')
   end
 end
 
@@ -171,7 +173,7 @@ describe "An instance method with a default argument" do
     def foo(a, b = 2)
       [a,b]
     end
-    -> { foo }.should raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1..2)')
+    -> { foo }.should.raise(ArgumentError, 'wrong number of arguments (given 0, expected 1..2)')
     foo(1).should == [1, 2]
   end
 
@@ -179,7 +181,7 @@ describe "An instance method with a default argument" do
     def foo(a, b = 2, *c)
       [a,b,c]
     end
-    -> { foo }.should raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1+)')
+    -> { foo }.should.raise(ArgumentError, 'wrong number of arguments (given 0, expected 1+)')
     foo(1).should == [1,2,[]]
   end
 
@@ -203,7 +205,7 @@ describe "An instance method with a default argument" do
         eval "def foo(bar = bar)
           bar
         end"
-      }.should raise_error(SyntaxError)
+      }.should.raise(SyntaxError)
     end
   end
 
@@ -277,26 +279,27 @@ describe "A singleton method definition" do
   it "raises FrozenError if frozen" do
     obj = Object.new
     obj.freeze
-    -> { def obj.foo; end }.should raise_error(FrozenError)
+    -> { def obj.foo; end }.should.raise(FrozenError)
   end
 
   it "raises FrozenError with the correct class name" do
     obj = Object.new
     obj.freeze
-    -> { def obj.foo; end }.should raise_error(FrozenError){ |e|
-      e.message.should.start_with? "can't modify frozen object"
-    }
+    msg_class = ruby_version_is("4.0") ? "Object" : "object"
+    -> { def obj.foo; end }.should.raise(FrozenError, "can't modify frozen #{msg_class}: #{obj}")
 
+    obj = Object.new
     c = obj.singleton_class
-    -> { def c.foo; end }.should raise_error(FrozenError){ |e|
-      e.message.should.start_with? "can't modify frozen Class"
-    }
+    c.singleton_class.freeze
+    -> { def c.foo; end }.should.raise(FrozenError, "can't modify frozen Class: #{c}")
+
+    c = Class.new
+    c.freeze
+    -> { def c.foo; end }.should.raise(FrozenError, "can't modify frozen Class: #{c}")
 
     m = Module.new
     m.freeze
-    -> { def m.foo; end }.should raise_error(FrozenError){ |e|
-      e.message.should.start_with? "can't modify frozen Module"
-    }
+    -> { def m.foo; end }.should.raise(FrozenError, "can't modify frozen Module: #{m}")
   end
 end
 
@@ -431,7 +434,7 @@ describe "A method definition inside a metaclass scope" do
     end
 
     DefSpecSingleton.a_class_method.should == DefSpecSingleton
-    -> { Object.a_class_method }.should raise_error(NoMethodError)
+    -> { Object.a_class_method }.should.raise(NoMethodError)
   end
 
   it "can create a singleton method" do
@@ -441,7 +444,7 @@ describe "A method definition inside a metaclass scope" do
     end
 
     obj.a_singleton_method.should == obj
-    -> { Object.new.a_singleton_method }.should raise_error(NoMethodError)
+    -> { Object.new.a_singleton_method }.should.raise(NoMethodError)
   end
 
   it "raises FrozenError if frozen" do
@@ -449,7 +452,7 @@ describe "A method definition inside a metaclass scope" do
     obj.freeze
 
     class << obj
-      -> { def foo; end }.should raise_error(FrozenError)
+      -> { def foo; end }.should.raise(FrozenError)
     end
   end
 end
@@ -470,7 +473,7 @@ describe "A nested method definition" do
     other = DefSpecNested.new
     other.an_instance_method.should == other
 
-    DefSpecNested.should have_instance_method(:an_instance_method)
+    DefSpecNested.should.method_defined?(:an_instance_method, false)
   end
 
   it "creates a class method when evaluated in a class method" do
@@ -485,11 +488,11 @@ describe "A nested method definition" do
       end
     end
 
-    -> { DefSpecNested.a_class_method }.should raise_error(NoMethodError)
+    -> { DefSpecNested.a_class_method }.should.raise(NoMethodError)
     DefSpecNested.create_class_method.should == DefSpecNested
     DefSpecNested.a_class_method.should == DefSpecNested
-    -> { Object.a_class_method }.should raise_error(NoMethodError)
-    -> { DefSpecNested.new.a_class_method }.should raise_error(NoMethodError)
+    -> { Object.a_class_method }.should.raise(NoMethodError)
+    -> { DefSpecNested.new.a_class_method }.should.raise(NoMethodError)
   end
 
   it "creates a singleton method when evaluated in the metaclass of an instance" do
@@ -507,7 +510,7 @@ describe "A nested method definition" do
     obj.a_singleton_method.should == obj
 
     other = DefSpecNested.new
-    -> { other.a_singleton_method }.should raise_error(NoMethodError)
+    -> { other.a_singleton_method }.should.raise(NoMethodError)
   end
 
   it "creates a method in the surrounding context when evaluated in a def expr.method" do
@@ -519,8 +522,8 @@ describe "A nested method definition" do
     end
 
     DefSpecNested::TARGET.defs_method
-    DefSpecNested.should have_instance_method :inherited_method
-    DefSpecNested::TARGET.should_not have_method :inherited_method
+    DefSpecNested.should.method_defined?(:inherited_method, false)
+    DefSpecNested::TARGET.should_not.respond_to? :inherited_method
 
     obj = DefSpecNested.new
     obj.inherited_method.should == obj
@@ -542,11 +545,11 @@ describe "A nested method definition" do
     obj = DefSpecNested::OBJ
     obj.create_method_in_instance_eval
 
-    obj.should have_method :arg_method
-    obj.should have_method :body_method
+    obj.should.respond_to? :arg_method
+    obj.should.respond_to? :body_method
 
-    DefSpecNested.should_not have_instance_method :arg_method
-    DefSpecNested.should_not have_instance_method :body_method
+    DefSpecNested.should_not.method_defined? :arg_method
+    DefSpecNested.should_not.method_defined? :body_method
   ensure
     DefSpecNested.send(:remove_const, :OBJ)
   end
@@ -566,7 +569,7 @@ describe "A nested method definition" do
 
     cls.new.new_def.should == 1
 
-    -> { Object.new.new_def }.should raise_error(NoMethodError)
+    -> { Object.new.new_def }.should.raise(NoMethodError)
   end
 end
 
@@ -582,18 +585,18 @@ describe "A method definition always resets the visibility to public for nested
     end
 
     obj = cls.new
-    -> { obj.do_def }.should raise_error(NoMethodError, /private/)
+    -> { obj.do_def }.should.raise(NoMethodError, /private/)
     obj.send :do_def
     obj.new_def.should == 1
 
     cls.new.new_def.should == 1
 
-    -> { Object.new.new_def }.should raise_error(NoMethodError)
+    -> { Object.new.new_def }.should.raise(NoMethodError)
   end
 
   it "at the toplevel" do
     obj = Object.new
-    -> { obj.toplevel_define_other_method }.should raise_error(NoMethodError, /private/)
+    -> { obj.toplevel_define_other_method }.should.raise(NoMethodError, /private/)
     toplevel_define_other_method
     nested_method_in_toplevel_method.should == 42
 
@@ -610,7 +613,7 @@ describe "A method definition inside an instance_eval" do
     obj.an_instance_eval_method.should == obj
 
     other = Object.new
-    -> { other.an_instance_eval_method }.should raise_error(NoMethodError)
+    -> { other.an_instance_eval_method }.should.raise(NoMethodError)
   end
 
   it "creates a singleton method when evaluated inside a metaclass" do
@@ -623,7 +626,7 @@ describe "A method definition inside an instance_eval" do
     obj.a_metaclass_eval_method.should == obj
 
     other = Object.new
-    -> { other.a_metaclass_eval_method }.should raise_error(NoMethodError)
+    -> { other.a_metaclass_eval_method }.should.raise(NoMethodError)
   end
 
   it "creates a class method when the receiver is a class" do
@@ -632,7 +635,7 @@ describe "A method definition inside an instance_eval" do
     end
 
     DefSpecNested.an_instance_eval_class_method.should == DefSpecNested
-    -> { Object.an_instance_eval_class_method }.should raise_error(NoMethodError)
+    -> { Object.an_instance_eval_class_method }.should.raise(NoMethodError)
   end
 
   it "creates a class method when the receiver is an anonymous class" do
@@ -644,7 +647,7 @@ describe "A method definition inside an instance_eval" do
     end
 
     m.klass_method.should == :test
-    -> { Object.klass_method }.should raise_error(NoMethodError)
+    -> { Object.klass_method }.should.raise(NoMethodError)
   end
 
   it "creates a class method when instance_eval is within class" do
@@ -657,7 +660,7 @@ describe "A method definition inside an instance_eval" do
     end
 
     m.klass_method.should == :test
-    -> { Object.klass_method }.should raise_error(NoMethodError)
+    -> { Object.klass_method }.should.raise(NoMethodError)
   end
 end
 
@@ -670,7 +673,7 @@ describe "A method definition inside an instance_exec" do
     end
 
     DefSpecNested.an_instance_exec_class_method.should == 1
-    -> { Object.an_instance_exec_class_method }.should raise_error(NoMethodError)
+    -> { Object.an_instance_exec_class_method }.should.raise(NoMethodError)
   end
 
   it "creates a class method when the receiver is an anonymous class" do
@@ -684,7 +687,7 @@ describe "A method definition inside an instance_exec" do
     end
 
     m.klass_method.should == 1
-    -> { Object.klass_method }.should raise_error(NoMethodError)
+    -> { Object.klass_method }.should.raise(NoMethodError)
   end
 
   it "creates a class method when instance_exec is within class" do
@@ -699,7 +702,7 @@ describe "A method definition inside an instance_exec" do
     end
 
     m.klass_method.should == 2
-    -> { Object.klass_method }.should raise_error(NoMethodError)
+    -> { Object.klass_method }.should.raise(NoMethodError)
   end
 end
 
@@ -719,7 +722,7 @@ describe "A method definition in an eval" do
     other = DefSpecNested.new
     other.an_eval_instance_method.should == other
 
-    -> { Object.new.an_eval_instance_method }.should raise_error(NoMethodError)
+    -> { Object.new.an_eval_instance_method }.should.raise(NoMethodError)
   end
 
   it "creates a class method" do
@@ -735,8 +738,8 @@ describe "A method definition in an eval" do
     DefSpecNestedB.eval_class_method.should == DefSpecNestedB
     DefSpecNestedB.an_eval_class_method.should == DefSpecNestedB
 
-    -> { Object.an_eval_class_method }.should raise_error(NoMethodError)
-    -> { DefSpecNestedB.new.an_eval_class_method}.should raise_error(NoMethodError)
+    -> { Object.an_eval_class_method }.should.raise(NoMethodError)
+    -> { DefSpecNestedB.new.an_eval_class_method}.should.raise(NoMethodError)
   end
 
   it "creates a singleton method" do
@@ -754,7 +757,7 @@ describe "A method definition in an eval" do
     obj.an_eval_singleton_method.should == obj
 
     other = DefSpecNested.new
-    -> { other.an_eval_singleton_method }.should raise_error(NoMethodError)
+    -> { other.an_eval_singleton_method }.should.raise(NoMethodError)
   end
 end
 
@@ -765,8 +768,8 @@ describe "a method definition that sets more than one default parameter all to t
   it "assigns them all the same object by default" do
     foo.should == [{},{},{}]
     a, b, c = foo
-    a.should eql(b)
-    a.should eql(c)
+    a.should.eql?(b)
+    a.should.eql?(c)
   end
 
   it "allows the first argument to be given, and sets the rest to null" do
@@ -776,11 +779,11 @@ describe "a method definition that sets more than one default parameter all to t
   it "assigns the parameters different objects across different default calls" do
     a, _b, _c = foo
     d, _e, _f = foo
-    a.should_not equal(d)
+    a.should_not.equal?(d)
   end
 
   it "only allows overriding the default value of the first such parameter in each set" do
-    -> { foo(1,2) }.should raise_error(ArgumentError, 'wrong number of arguments (given 2, expected 0..1)')
+    -> { foo(1,2) }.should.raise(ArgumentError, 'wrong number of arguments (given 2, expected 0..1)')
   end
 
   def bar(a=b=c=1,d=2)
@@ -791,7 +794,7 @@ describe "a method definition that sets more than one default parameter all to t
     bar.should == [1,1,1,2]
     bar(3).should == [3,nil,nil,2]
     bar(3,4).should == [3,nil,nil,4]
-    -> { bar(3,4,5) }.should raise_error(ArgumentError, 'wrong number of arguments (given 3, expected 0..2)')
+    -> { bar(3,4,5) }.should.raise(ArgumentError, 'wrong number of arguments (given 3, expected 0..2)')
   end
 end
 
@@ -806,7 +809,7 @@ describe "The def keyword" do
         }.call
       end
 
-      DefSpecsLambdaVisibility.should have_private_instance_method("some_method")
+      DefSpecsLambdaVisibility.private_instance_methods(false).should.include?(:some_method)
     end
   end
 end