Upstream specs

core/dir/chdir_spec.rb

@@ -95,10 +95,10 @@ def to_str;  DirSpecs.mock_dir; end
   end
 
   it "raises an Errno::ENOENT if the original directory no longer exists" do
-    dir1 = tmp('/testdir1')
-    dir2 = tmp('/testdir2')
-    File.should_not.exist?(dir1)
-    File.should_not.exist?(dir2)
+    dir1 = tmp('testdir1')
+    dir2 = tmp('testdir2')
+    Dir.should_not.exist?(dir1)
+    Dir.should_not.exist?(dir2)
     Dir.mkdir dir1
     Dir.mkdir dir2
     begin
@@ -108,8 +108,8 @@ def to_str;  DirSpecs.mock_dir; end
         end
       }.should raise_error(Errno::ENOENT)
     ensure
-      Dir.unlink dir1 if File.exist?(dir1)
-      Dir.unlink dir2 if File.exist?(dir2)
+      Dir.unlink dir1 if Dir.exist?(dir1)
+      Dir.unlink dir2 if Dir.exist?(dir2)
     end
   end
 
@@ -177,28 +177,29 @@ def to_str;  DirSpecs.mock_dir; end
       dir.close
     end
 
-    it "raises an Errno::ENOENT if the original directory no longer exists" do
-      dir_name1 = tmp('/testdir1')
-      dir_name2 = tmp('/testdir2')
-      File.should_not.exist?(dir_name1)
-      File.should_not.exist?(dir_name2)
-      Dir.mkdir dir_name1
-      Dir.mkdir dir_name2
+    platform_is_not :windows do
+      it "does not raise an Errno::ENOENT if the original directory no longer exists" do
+        dir_name1 = tmp('testdir1')
+        dir_name2 = tmp('testdir2')
+        Dir.should_not.exist?(dir_name1)
+        Dir.should_not.exist?(dir_name2)
+        Dir.mkdir dir_name1
+        Dir.mkdir dir_name2
 
-      dir1 = Dir.new(dir_name1)
+        dir2 = Dir.new(dir_name2)
 
-      begin
-        -> {
-          dir1.chdir do
-            Dir.chdir(dir_name2) { Dir.unlink dir_name1 }
+        begin
+          Dir.chdir(dir_name1) do
+            dir2.chdir { Dir.unlink dir_name1 }
           end
-        }.should raise_error(Errno::ENOENT)
+          Dir.pwd.should == @original
+        ensure
+          Dir.unlink dir_name1 if Dir.exist?(dir_name1)
+          Dir.unlink dir_name2 if Dir.exist?(dir_name2)
+        end
       ensure
-        Dir.unlink dir_name1 if File.exist?(dir_name1)
-        Dir.unlink dir_name2 if File.exist?(dir_name2)
+        dir2.close
       end
-    ensure
-      dir1.close
     end
 
     it "always returns to the original directory when given a block" do

core/dir/for_fd_spec.rb

@@ -1,6 +1,7 @@
 require_relative '../../spec_helper'
 require_relative 'fixtures/common'
 
+quarantine! do # leads to "Errno::EBADF: Bad file descriptor - closedir" in DirSpecs.delete_mock_dirs
 ruby_version_is '3.3' do
   guard -> { Dir.respond_to? :for_fd } do
     describe "Dir.for_fd" do
@@ -42,8 +43,8 @@
 
       it "calls #to_int to convert a value to an Integer" do
         dir = Dir.new(DirSpecs.mock_dir)
-        obj = Object.new
-        obj.singleton_class.define_method(:to_int) { dir.fileno }
+        obj = mock("fd")
+        obj.should_receive(:to_int).and_return(dir.fileno)
 
         dir_new = Dir.for_fd(obj)
         dir_new.fileno.should == dir.fileno
@@ -75,3 +76,4 @@
     end
   end
 end
+end

core/exception/fixtures/common.rb

@@ -84,6 +84,9 @@ class NoMethodErrorD; end
 
   class InstanceException < Exception
   end
+
+  class AClass; end
+  module AModule; end
 end
 
 class NameErrorSpecs

core/exception/no_method_error_spec.rb

@@ -67,7 +67,7 @@
   end
 
   ruby_version_is ""..."3.3" do
-    it "calls receiver.inspect only when calling Exception#message" do
+    it "calls #inspect when calling Exception#message" do
       ScratchPad.record []
       test_class = Class.new do
         def inspect
@@ -76,19 +76,163 @@ def inspect
         end
       end
       instance = test_class.new
+
       begin
         instance.bar
-      rescue Exception => e
-        e.name.should == :bar
-        ScratchPad.recorded.should == []
-        e.message.should =~ /undefined method.+\bbar\b/
+      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
+    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
+    end
   end
 
   ruby_version_is "3.3" do
-    it "does not call receiver.inspect even when calling Exception#message" 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
+    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 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 #name when receiver 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 class MyClass\Z/
+      end
+    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 #<Class: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
+
+      begin
+        singleton_class.foo
+      rescue NoMethodError => error
+        error.message.should =~ /\Aundefined method [`']foo' for class #<Class:#<Object:0x\h+>>\Z/
+      end
+    end
+
+    it "uses #name when receiver 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 module MyModule\Z/
+      end
+    end
+
+    it "uses module's string representation when receiver is an anonymous module" do
+      m = Module.new
+
+      begin
+        m.foo
+      rescue NoMethodError => error
+        error.message.should =~ /\Aundefined method [`']foo' for module #<Module:0x\h+>\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
+
+      begin
+        instance.bar
+      rescue NoMethodError => error
+        error.message.should =~ /\Aundefined method [`']bar' for an instance of MyClass\Z/
+      end
+    end
+
+    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 #<Class: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/
+      end
+    end
+
+    it "does not call #inspect when calling Exception#message" do
       ScratchPad.record []
       test_class = Class.new do
         def inspect
@@ -97,47 +241,29 @@ def inspect
         end
       end
       instance = test_class.new
+
       begin
         instance.bar
-      rescue Exception => e
-        e.name.should == :bar
-        ScratchPad.recorded.should == []
-        e.message.should =~ /undefined method.+\bbar\b/
+      rescue NoMethodError => error
+        error.message.should =~ /\Aundefined method [`']bar' for an instance of #<Class:0x\h+>\Z/
         ScratchPad.recorded.should == []
       end
     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 Exception => e
-      e.name.should == :bar
-      message = e.message
-      message.should =~ /undefined method.+\bbar\b/
-      message.should include test_class.inspect
-    end
-  end
+    it "does not truncate long class names" do
+      class_name = 'ExceptionSpecs::A' + 'a'*100
 
-  it "uses #name to display the receiver if it is a class or a module" do
-    klass = Class.new { def self.name; "MyClass"; end }
-    begin
-      klass.foo
-    rescue NoMethodError => error
-      error.message.lines.first.chomp.should =~ /^undefined method [`']foo' for /
-    end
+      begin
+        eval <<~RUBY
+          class #{class_name}
+          end
 
-    mod = Module.new { def self.name; "MyModule"; end }
-    begin
-      mod.foo
-    rescue NoMethodError => error
-      error.message.lines.first.chomp.should =~ /^undefined method [`']foo' for /
+          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
 end

core/integer/divide_spec.rb

@@ -12,6 +12,17 @@
 
     it "supports dividing negative numbers" do
       (-1 / 10).should == -1
+      (-1 / 10**10).should == -1
+      (-1 / 10**20).should == -1
+    end
+
+    it "preservers sign correctly" do
+      (4 / 3).should == 1
+      (4 / -3).should == -2
+      (-4 / 3).should == -2
+      (-4 / -3).should == 1
+      (0 / -3).should == 0
+      (0 / 3).should == 0
     end
 
     it "returns result the same class as the argument" do
@@ -58,6 +69,15 @@
       ((10**50) / -(10**40 + 1)).should == -10000000000
     end
 
+    it "preservers sign correctly" do
+      (4 / bignum_value).should == 0
+      (4 / -bignum_value).should == -1
+      (-4 / bignum_value).should == -1
+      (-4 / -bignum_value).should == 0
+      (0 / bignum_value).should == 0
+      (0 / -bignum_value).should == 0
+    end
+
     it "returns self divided by Float" do
       not_supported_on :opal do
         (bignum_value(88) / 4294967295.0).should be_close(4294967297.0, TOLERANCE)