Update to ruby/spec@83e26c9

1 files changed, 101 insertions, 160 deletions

diff --git a/spec/ruby/core/exception/no_method_error_spec.rb b/spec/ruby/core/exception/no_method_error_spec.rb
index 772c569f67..d20878c6e3 100644
--- a/spec/ruby/core/exception/no_method_error_spec.rb
+++ b/spec/ruby/core/exception/no_method_error_spec.rb
@@ -66,204 +66,145 @@ describe "NoMethodError#message" do
     end
   end
 
-  ruby_version_is ""..."3.3" do
-    it "calls #inspect when calling Exception#message" do
-      ScratchPad.record []
-      test_class = Class.new do
-        def inspect
-          ScratchPad << :inspect_called
-          "<inspect>"
-        end
-      end
-      instance = test_class.new
-
-      begin
-        instance.bar
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']bar' for <inspect>:#<Class:0x\h+>$/
-        ScratchPad.recorded.should == [:inspect_called]
-      end
-    end
-
-    it "fallbacks to a simpler representation of the receiver when receiver.inspect raises an exception" do
-      test_class = Class.new do
-        def inspect
-          raise NoMethodErrorSpecs::InstanceException
-        end
-      end
-      instance = test_class.new
-
-      begin
-        instance.bar
-      rescue NoMethodError => error
-        message = error.message
-        message.should =~ /undefined method.+\bbar\b/
-        message.should include test_class.inspect
-      end
-    end
-
-    it "uses #name to display the receiver if it is a class" do
-      klass = Class.new { def self.name; "MyClass"; end }
-
-      begin
-        klass.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for MyClass:Class$/
-      end
+  it "uses a literal name when receiver is nil" do
+    begin
+      nil.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for nil\Z/
     end
+  end
 
-    it "uses #name to display the receiver if it is a module" do
-      mod = Module.new { def self.name; "MyModule"; end }
-
-      begin
-        mod.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for MyModule:Module$/
-      end
+  it "uses a literal name when receiver is true" do
+    begin
+      true.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for true\Z/
     end
   end
 
-  ruby_version_is "3.3" do
-    it "uses a literal name when receiver is nil" do
-      begin
-        nil.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for nil\Z/
-      end
+  it "uses a literal name when receiver is false" do
+    begin
+      false.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for false\Z/
     end
+  end
 
-    it "uses a literal name when receiver is true" do
-      begin
-        true.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for true\Z/
-      end
-    end
+  it "uses #name when receiver is a class" do
+    klass = Class.new { def self.name; "MyClass"; end }
 
-    it "uses a literal name when receiver is false" do
-      begin
-        false.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for false\Z/
-      end
+    begin
+      klass.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for class MyClass\Z/
     end
+  end
 
-    it "uses #name when receiver is a class" do
-      klass = Class.new { def self.name; "MyClass"; end }
+  it "uses class' string representation when receiver is an anonymous class" do
+    klass = Class.new
 
-      begin
-        klass.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for class MyClass\Z/
-      end
+    begin
+      klass.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for class #<Class:0x\h+>\Z/
     end
+  end
 
-    it "uses class' string representation when receiver is an anonymous class" do
-      klass = Class.new
+  it "uses class' string representation when receiver is a singleton class" do
+    obj = Object.new
+    singleton_class = obj.singleton_class
 
-      begin
-        klass.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for class #<Class:0x\h+>\Z/
-      end
+    begin
+      singleton_class.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for class #<Class:#<Object:0x\h+>>\Z/
     end
+  end
 
-    it "uses class' string representation when receiver is a singleton class" do
-      obj = Object.new
-      singleton_class = obj.singleton_class
+  it "uses #name when receiver is a module" do
+    mod = Module.new { def self.name; "MyModule"; end }
 
-      begin
-        singleton_class.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for class #<Class:#<Object:0x\h+>>\Z/
-      end
+    begin
+      mod.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for module MyModule\Z/
     end
+  end
 
-    it "uses #name when receiver is a module" do
-      mod = Module.new { def self.name; "MyModule"; end }
+  it "uses module's string representation when receiver is an anonymous module" do
+    m = Module.new
 
-      begin
-        mod.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for module MyModule\Z/
-      end
+    begin
+      m.foo
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for module #<Module:0x\h+>\Z/
     end
+  end
 
-    it "uses module's string representation when receiver is an anonymous module" do
-      m = Module.new
+  it "uses class #name when receiver is an ordinary object" do
+    klass = Class.new { def self.name; "MyClass"; end }
+    instance = klass.new
 
-      begin
-        m.foo
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for module #<Module:0x\h+>\Z/
-      end
+    begin
+      instance.bar
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']bar' for an instance of MyClass\Z/
     end
+  end
 
-    it "uses class #name when receiver is an ordinary object" do
-      klass = Class.new { def self.name; "MyClass"; end }
-      instance = klass.new
+  it "uses class string representation when receiver is an instance of anonymous class" do
+    klass = Class.new
+    instance = klass.new
 
-      begin
-        instance.bar
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']bar' for an instance of MyClass\Z/
-      end
+    begin
+      instance.bar
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']bar' for an instance of #<Class:0x\h+>\Z/
     end
+  end
 
-    it "uses class string representation when receiver is an instance of anonymous class" do
-      klass = Class.new
-      instance = klass.new
+  it "uses class name when receiver has a singleton class" do
+    instance = NoMethodErrorSpecs::NoMethodErrorA.new
+    def instance.foo; end
 
-      begin
-        instance.bar
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']bar' for an instance of #<Class:0x\h+>\Z/
-      end
+    begin
+      instance.bar
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']bar' for #<NoMethodErrorSpecs::NoMethodErrorA:0x\h+>\Z/
     end
+  end
 
-    it "uses class name when receiver has a singleton class" do
-      instance = NoMethodErrorSpecs::NoMethodErrorA.new
-      def instance.foo; end
-
-      begin
-        instance.bar
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']bar' for #<NoMethodErrorSpecs::NoMethodErrorA:0x\h+>\Z/
+  it "does not call #inspect when calling Exception#message" do
+    ScratchPad.record []
+    test_class = Class.new do
+      def inspect
+        ScratchPad << :inspect_called
+        "<inspect>"
       end
     end
+    instance = test_class.new
 
-    it "does not call #inspect when calling Exception#message" do
-      ScratchPad.record []
-      test_class = Class.new do
-        def inspect
-          ScratchPad << :inspect_called
-          "<inspect>"
-        end
-      end
-      instance = test_class.new
-
-      begin
-        instance.bar
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']bar' for an instance of #<Class:0x\h+>\Z/
-        ScratchPad.recorded.should == []
-      end
+    begin
+      instance.bar
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']bar' for an instance of #<Class:0x\h+>\Z/
+      ScratchPad.recorded.should == []
     end
+  end
 
-    it "does not truncate long class names" do
-      class_name = 'ExceptionSpecs::A' + 'a'*100
+  it "does not truncate long class names" do
+    class_name = 'ExceptionSpecs::A' + 'a'*100
 
-      begin
-        eval <<~RUBY
-          class #{class_name}
-          end
+    begin
+      eval <<~RUBY
+        class #{class_name}
+        end
 
-          obj = #{class_name}.new
-          obj.foo
-        RUBY
-      rescue NoMethodError => error
-        error.message.should =~ /\Aundefined method [`']foo' for an instance of #{class_name}\Z/
-      end
+        obj = #{class_name}.new
+        obj.foo
+      RUBY
+    rescue NoMethodError => error
+      error.message.should =~ /\Aundefined method [`']foo' for an instance of #{class_name}\Z/
     end
   end
 end