Update to ruby/spec@c3206f6

Author: eregon

spec/ruby/core/array/assoc_spec.rb

@@ -37,4 +37,16 @@
     a.assoc(s1.first).should equal(s1)
     a.assoc(s2.first).should equal(s2)
   end
+
+  it "calls to_ary on non-array elements" do
+    s1 = [1, 2]
+    s2 = ArraySpecs::ArrayConvertible.new(2, 3)
+    a = [s1, s2]
+
+    s1.should_not_receive(:to_ary)
+    a.assoc(s1.first).should equal(s1)
+
+    a.assoc(2).should == [2, 3]
+    s2.called.should equal(:to_ary)
+  end
 end

spec/ruby/core/array/rassoc_spec.rb

@@ -35,4 +35,16 @@ def o.==(other); other == 'foobar'; end
 
     [[1, :foobar, o], [2, o, 1], [3, mock('foo')]].rassoc(key).should == [2, o, 1]
   end
+
+  it "does not call to_ary on non-array elements" do
+    s1 = [1, 2]
+    s2 = ArraySpecs::ArrayConvertible.new(2, 3)
+    a = [s1, s2]
+
+    s1.should_not_receive(:to_ary)
+    a.rassoc(2).should equal(s1)
+
+    s2.should_not_receive(:to_ary)
+    a.rassoc(3).should equal(nil)
+  end
 end

spec/ruby/core/exception/full_message_spec.rb

@@ -46,6 +46,49 @@
     full_message[0].should.end_with?("': Some runtime error (RuntimeError)\n")
   end
 
+  describe "includes details about whether an exception was handled" do
+    describe "RuntimeError" do
+      it "should report as unhandled if message is empty" do
+        err = RuntimeError.new("")
+
+        err.full_message.should =~ /unhandled exception/
+        err.full_message(highlight: true).should =~ /unhandled exception/
+        err.full_message(highlight: false).should =~ /unhandled exception/
+      end
+
+      it "should not report as unhandled if the message is not empty" do
+        err = RuntimeError.new("non-empty")
+
+        err.full_message.should !~ /unhandled exception/
+        err.full_message(highlight: true).should !~ /unhandled exception/
+        err.full_message(highlight: false).should !~ /unhandled exception/
+      end
+
+      it "should not report as unhandled if the message is nil" do
+        err = RuntimeError.new(nil)
+
+        err.full_message.should !~ /unhandled exception/
+        err.full_message(highlight: true).should !~ /unhandled exception/
+        err.full_message(highlight: false).should !~ /unhandled exception/
+      end
+
+      it "should not report as unhandled if the message is not specified" do
+        err = RuntimeError.new()
+
+        err.full_message.should !~ /unhandled exception/
+        err.full_message(highlight: true).should !~ /unhandled exception/
+        err.full_message(highlight: false).should !~ /unhandled exception/
+      end
+    end
+
+    describe "generic Error" do
+      it "should not report as unhandled in any event" do
+        StandardError.new("").full_message.should !~ /unhandled exception/
+        StandardError.new("non-empty").full_message.should !~ /unhandled exception/
+      end
+    end
+  end
+
   it "shows the exception class at the end of the first line of the message when the message contains multiple lines" do
     begin
       line = __LINE__; raise "first line\nsecond line"

spec/ruby/core/file/new_spec.rb

@@ -100,7 +100,7 @@
     File.should.exist?(@file)
   end
 
-  it "raises an Errorno::EEXIST if the file exists when create a new file with File::CREAT|File::EXCL" do
+  it "raises an Errno::EEXIST if the file exists when create a new file with File::CREAT|File::EXCL" do
     -> { @fh = File.new(@file, File::CREAT|File::EXCL) }.should raise_error(Errno::EEXIST)
   end
 

spec/ruby/core/file/open_spec.rb

@@ -354,7 +354,7 @@
     end
   end
 
-  it "raises an Errorno::EEXIST if the file exists when open with File::CREAT|File::EXCL" do
+  it "raises an Errno::EEXIST if the file exists when open with File::CREAT|File::EXCL" do
     -> {
       File.open(@file, File::CREAT|File::EXCL) do |f|
         f.puts("writing")
@@ -423,7 +423,7 @@
       }.should raise_error(IOError)
     end
 
-    it "raises an Errorno::EEXIST if the file exists when open with File::RDONLY|File::TRUNC" do
+    it "raises an Errno::EEXIST if the file exists when open with File::RDONLY|File::TRUNC" do
       -> {
         File.open(@file, File::RDONLY|File::TRUNC) do |f|
           f.puts("writing").should == nil
@@ -441,7 +441,7 @@
       }.should raise_error(Errno::EINVAL)
     end
 
-    it "raises an Errorno::EEXIST if the file exists when open with File::RDONLY|File::TRUNC" do
+    it "raises an Errno::EEXIST if the file exists when open with File::RDONLY|File::TRUNC" do
       -> {
         File.open(@file, File::RDONLY|File::TRUNC) do |f|
           f.puts("writing").should == nil

spec/ruby/core/kernel/Integer_spec.rb

@@ -586,6 +586,21 @@
     Integer("777", obj).should == 0777
   end
 
+  # https://bugs.ruby-lang.org/issues/19349
+  ruby_version_is ''...'3.3' do
+    it "ignores the base if it is not an integer and does not respond to #to_i" do
+      Integer("777", "8").should == 777
+    end
+  end
+
+  ruby_version_is '3.3' do
+    it "raises a TypeError if it is not an integer and does not respond to #to_i" do
+      -> {
+        Integer("777", "8")
+      }.should raise_error(TypeError, "no implicit conversion of String into Integer")
+    end
+  end
+
   describe "when passed exception: false" do
     describe "and valid argument" do
       it "returns an Integer number" do

spec/ruby/core/method/parameters_spec.rb

@@ -7,6 +7,7 @@ def one_key(a: 1); end
     def one_keyrest(**a); end
 
     def one_keyreq(a:); end
+    def one_nokey(**nil); end
 
     def one_splat_one_req(*a,b); end
     def one_splat_two_req(*a,b,c); end
@@ -15,6 +16,7 @@ def one_splat_one_req_with_block(*a,b,&blk); end
     def one_opt_with_stabby(a=-> b { true }); end
 
     def one_unnamed_splat(*); end
+    def one_unnamed_keyrest(**); end
 
     def one_splat_one_block(*args, &block)
       local_is_not_parameter = {}
@@ -178,6 +180,11 @@ def underscore_parameters(_, _, _ = 1, *_, _:, _: 2, **_, &_); end
     m.parameters.should == [[:keyreq,:a]]
   end
 
+  it "returns [[:nokey]] for a method with a single **nil parameter" do
+    m = MethodSpecs::Methods.instance_method(:one_nokey)
+    m.parameters.should == [[:nokey]]
+  end
+
   it "works with ->(){} as the value of an optional argument" do
     m = MethodSpecs::Methods.instance_method(:one_opt_with_stabby)
     m.parameters.should == [[:opt,:a]]
@@ -225,17 +232,39 @@ def underscore_parameters(_, _, _ = 1, *_, _:, _: 2, **_, &_); end
   end
 
   ruby_version_is '3.2' do
-    it "adds * rest arg for \"star\" argument" do
+    it "adds rest arg with name * for \"star\" argument" do
       m = MethodSpecs::Methods.new
       m.method(:one_unnamed_splat).parameters.should == [[:rest, :*]]
     end
+
+    it "adds keyrest arg with ** as a name for \"double star\" argument" do
+      m = MethodSpecs::Methods.new
+      m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest, :**]]
+    end
   end
 
   ruby_version_is ''...'3.2' do
     it "adds nameless rest arg for \"star\" argument" do
       m = MethodSpecs::Methods.new
       m.method(:one_unnamed_splat).parameters.should == [[:rest]]
     end
+
+    it "adds nameless keyrest arg for \"double star\" argument" do
+      m = MethodSpecs::Methods.new
+      m.method(:one_unnamed_keyrest).parameters.should == [[:keyrest]]
+    end
+  end
+
+  ruby_version_is '3.1' do
+    it "adds block arg with name & for anonymous block argument" do
+      object = Object.new
+
+      eval(<<~RUBY).should == [[:block, :&]]
+        def object.foo(&)
+        end
+        object.method(:foo).parameters
+      RUBY
+    end
   end
 
   it "returns the args and block for a splat and block argument" do

spec/ruby/core/proc/parameters_spec.rb

@@ -21,7 +21,7 @@
   end
 
   ruby_version_is "3.2" do
-    it "sets the first element of each sub-Array to :req if argument would be required if a lambda if lambda keyword used" do
+    it "sets the first element of each sub-Array to :req for required argument if lambda keyword used" do
       proc {|x| }.parameters(lambda: true).first.first.should == :req
       proc {|y,*x| }.parameters(lambda: true).first.first.should == :req
     end
@@ -91,19 +91,33 @@
     proc {|&block| }.parameters.first.last.should == :block
   end
 
-  it "ignores unnamed rest args" do
+  it "ignores unnamed rest arguments" do
     -> x {}.parameters.should == [[:req, :x]]
   end
 
   ruby_version_is '3.2' do
-    it "adds * rest arg for \"star\" argument" do
-      -> x, * {}.parameters.should == [[:req, :x], [:rest, :*]]
+    it "adds rest arg with name * for \"star\" argument" do
+      -> * {}.parameters.should == [[:rest, :*]]
+    end
+
+    it "adds keyrest arg with ** as a name for \"double star\" argument" do
+      -> ** {}.parameters.should == [[:keyrest, :**]]
     end
   end
 
   ruby_version_is ''...'3.2' do
     it "adds nameless rest arg for \"star\" argument" do
-      -> x, * {}.parameters.should == [[:req, :x], [:rest]]
+      -> * {}.parameters.should == [[:rest]]
+    end
+
+    it "adds nameless keyrest arg for \"double star\" argument" do
+      -> ** {}.parameters.should == [[:keyrest]]
+    end
+  end
+
+  ruby_version_is '3.1' do
+    it "adds block arg with name & for anonymous block argument" do
+      eval('-> & {}.parameters').should == [[:block, :&]]
     end
   end
 

spec/ruby/language/numbered_parameters_spec.rb

@@ -82,6 +82,19 @@
     lambda { _9 }.arity.should == 9
   end
 
+  it "affects block parameters" do
+    -> { _1 }.parameters.should == [[:req, :_1]]
+    -> { _2 }.parameters.should == [[:req, :_1], [:req, :_2]]
+
+    proc { _1 }.parameters.should == [[:opt, :_1]]
+    proc { _2 }.parameters.should == [[:opt, :_1], [:opt, :_2]]
+  end
+
+  it "affects binding local variables" do
+    -> { _1; binding.local_variables }.call("a").should == [:_1]
+    -> { _2; binding.local_variables }.call("a", "b").should == [:_1, :_2]
+  end
+
   it "does not work in methods" do
     obj = Object.new
     def obj.foo; _1 end

spec/ruby/language/singleton_class_spec.rb

@@ -307,4 +307,11 @@ def singleton_method; 1 end
     o.freeze
     klass.frozen?.should == true
   end
+
+  it "will be unfrozen if the frozen object is cloned with freeze set to false" do
+    o = Object.new
+    o.freeze
+    o2 = o.clone(freeze: false)
+    o2.singleton_class.frozen?.should == false
+  end
 end