Update to ruby/spec@41bf282

18 files changed, 238 insertions, 18 deletions

diff --git a/spec/ruby/core/array/shared/slice.rb b/spec/ruby/core/array/shared/slice.rb
index 1e7fdf934a..d6b4547b2b 100644
--- a/spec/ruby/core/array/shared/slice.rb
+++ b/spec/ruby/core/array/shared/slice.rb
@@ -461,7 +461,7 @@ describe :array_slice, shared: true do
   it "raises a RangeError when the start index is out of range of Fixnum" do
     array = [1, 2, 3, 4, 5, 6]
     obj = mock('large value')
-    obj.should_receive(:to_int).and_return(0x8000_0000_0000_0000_0000)
+    obj.should_receive(:to_int).and_return(bignum_value)
     -> { array.send(@method, obj) }.should raise_error(RangeError)
 
     obj = 8e19
@@ -471,10 +471,19 @@ describe :array_slice, shared: true do
   it "raises a RangeError when the length is out of range of Fixnum" do
     array = [1, 2, 3, 4, 5, 6]
     obj = mock('large value')
-    obj.should_receive(:to_int).and_return(0x8000_0000_0000_0000_0000)
+    obj.should_receive(:to_int).and_return(bignum_value)
     -> { array.send(@method, 1, obj) }.should raise_error(RangeError)
 
     obj = 8e19
     -> { array.send(@method, 1, obj) }.should raise_error(RangeError)
   end
+
+  it "raises a type error if a range is passed with a length" do
+    ->{ [1, 2, 3].send(@method, 1..2, 1) }.should raise_error(TypeError)
+  end
+
+  it "raises a RangeError if passed a range with a bound that is too large" do
+    -> { "hello".send(@method, bignum_value..(bignum_value + 1)) }.should raise_error(RangeError)
+    -> { "hello".send(@method, 0..bignum_value) }.should raise_error(RangeError)
+  end
 end
diff --git a/spec/ruby/core/binding/eval_spec.rb b/spec/ruby/core/binding/eval_spec.rb
index 84096f8a91..224bce4c33 100644
--- a/spec/ruby/core/binding/eval_spec.rb
+++ b/spec/ruby/core/binding/eval_spec.rb
@@ -131,4 +131,10 @@ describe "Binding#eval" do
     bind, meth = obj.get_binding_with_send_and_method
     bind.eval("__method__").should == meth
   end
+
+  it "reflects refinements activated in the binding scope" do
+    bind = BindingSpecs::Refined.refined_binding
+
+    bind.eval("'bar'.foo").should == "foo"
+  end
 end
diff --git a/spec/ruby/core/binding/fixtures/classes.rb b/spec/ruby/core/binding/fixtures/classes.rb
index 43e32cacf6..b5f3ce9008 100644
--- a/spec/ruby/core/binding/fixtures/classes.rb
+++ b/spec/ruby/core/binding/fixtures/classes.rb
@@ -49,4 +49,18 @@ module BindingSpecs
       end
     end
   end
+
+  module AddFooToString
+    refine(String) do
+      def foo
+        "foo"
+      end
+    end
+  end
+  class Refined
+    using AddFooToString
+    def self.refined_binding
+      binding
+    end
+  end
 end
diff --git a/spec/ruby/core/file/realpath_spec.rb b/spec/ruby/core/file/realpath_spec.rb
index 0c5d19287a..bd27e09da6 100644
--- a/spec/ruby/core/file/realpath_spec.rb
+++ b/spec/ruby/core/file/realpath_spec.rb
@@ -67,6 +67,12 @@ platform_is_not :windows do
     it "raises Errno::ENOENT if the symlink points to an absent file" do
       -> { File.realpath(@fake_link) }.should raise_error(Errno::ENOENT)
     end
+
+    it "converts the argument with #to_path" do
+      path = mock("path")
+      path.should_receive(:to_path).and_return(__FILE__)
+      File.realpath(path).should == File.realpath(__FILE__ )
+    end
   end
 end
 
diff --git a/spec/ruby/core/file/stat_spec.rb b/spec/ruby/core/file/stat_spec.rb
index 31f9dc58af..76b0becbf0 100644
--- a/spec/ruby/core/file/stat_spec.rb
+++ b/spec/ruby/core/file/stat_spec.rb
@@ -41,5 +41,14 @@ platform_is_not :windows do
       st.file?.should == true
       st.symlink?.should == false
     end
+
+    it "returns an error when given missing non-ASCII path" do
+      missing_path = "/missingfilepath\xE3E4".force_encoding("ASCII-8BIT")
+      -> {
+        File.stat(missing_path)
+      }.should raise_error(Errno::ENOENT) { |e|
+        e.message.should include(missing_path)
+      }
+    end
   end
 end
diff --git a/spec/ruby/core/integer/lte_spec.rb b/spec/ruby/core/integer/lte_spec.rb
index 3d843a5dd9..40a89f094a 100644
--- a/spec/ruby/core/integer/lte_spec.rb
+++ b/spec/ruby/core/integer/lte_spec.rb
@@ -46,6 +46,11 @@ describe "Integer#<=" do
       (@bignum <= (@bignum + 0.5)).should == false
     end
 
+    it "returns true for bignums compare to a bigger float" do
+      (18446744073709551616 <= 1.8446744073709552e+19).should == true
+      (@bignum <= (@bignum + 9999.0)).should == true
+    end
+
     it "raises an ArgumentError when given a non-Integer" do
       -> { @bignum <= "4" }.should raise_error(ArgumentError)
       -> { @bignum <= mock('str') }.should raise_error(ArgumentError)
diff --git a/spec/ruby/core/kernel/caller_locations_spec.rb b/spec/ruby/core/kernel/caller_locations_spec.rb
index 8f9429845d..cb344e16a0 100644
--- a/spec/ruby/core/kernel/caller_locations_spec.rb
+++ b/spec/ruby/core/kernel/caller_locations_spec.rb
@@ -28,6 +28,14 @@ describe 'Kernel#caller_locations' do
     locations1[2..4].map(&:to_s).should == locations2.map(&:to_s)
   end
 
+  ruby_version_is "2.6" do
+    it "works with endless ranges" do
+      locations1 = caller_locations(0)
+      locations2 = caller_locations(eval("(2..)"))
+      locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
+    end
+  end
+
   it "can be called with a range whose end is negative" do
     locations1 = caller_locations(0)
     locations2 = caller_locations(2..-1)
diff --git a/spec/ruby/core/kernel/caller_spec.rb b/spec/ruby/core/kernel/caller_spec.rb
index 8469319c94..e943e36dc2 100644
--- a/spec/ruby/core/kernel/caller_spec.rb
+++ b/spec/ruby/core/kernel/caller_spec.rb
@@ -43,4 +43,12 @@ describe 'Kernel#caller' do
       "#{path}:2:in `block in <main>'\n"
     ]
   end
+
+  ruby_version_is "2.6" do
+    it "works with endless ranges" do
+      locations1 = KernelSpecs::CallerTest.locations(0)
+      locations2 = KernelSpecs::CallerTest.locations(eval("(2..)"))
+      locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
+    end
+  end
 end
diff --git a/spec/ruby/core/kernel/eval_spec.rb b/spec/ruby/core/kernel/eval_spec.rb
index 09ccb9dc62..783009ac01 100644
--- a/spec/ruby/core/kernel/eval_spec.rb
+++ b/spec/ruby/core/kernel/eval_spec.rb
@@ -373,4 +373,44 @@ CODE
       EvalSpecs.send :remove_const, :Vπstring_not_frozen
     end
   end
+
+  it "activates refinements from the eval scope" do
+    refinery = Module.new do
+      refine EvalSpecs::A do
+        def foo
+          "bar"
+        end
+      end
+    end
+
+    result = nil
+
+    Module.new do
+      using refinery
+
+      result = eval "EvalSpecs::A.new.foo"
+    end
+
+    result.should == "bar"
+  end
+
+  it "activates refinements from the binding" do
+    refinery = Module.new do
+      refine EvalSpecs::A do
+        def foo
+          "bar"
+        end
+      end
+    end
+
+    b = nil
+    m = Module.new do
+      using refinery
+      b = binding
+    end
+
+    result = eval "EvalSpecs::A.new.foo", b
+
+    result.should == "bar"
+  end
 end
diff --git a/spec/ruby/core/module/name_spec.rb b/spec/ruby/core/module/name_spec.rb
index 36a91f5be5..9a4730313f 100644
--- a/spec/ruby/core/module/name_spec.rb
+++ b/spec/ruby/core/module/name_spec.rb
@@ -18,6 +18,12 @@ describe "Module#name" do
     m::N.name.should =~ /\A#<Module:0x[0-9a-f]+>::N\z/
   end
 
+  it "returns nil for a singleton class" do
+    Module.new.singleton_class.name.should be_nil
+    String.singleton_class.name.should be_nil
+    Object.new.singleton_class.name.should be_nil
+  end
+
   it "changes when the module is reachable through a constant path" do
     m = Module.new
     module m::N; end
diff --git a/spec/ruby/core/module/shared/class_eval.rb b/spec/ruby/core/module/shared/class_eval.rb
index 08f8ff7597..224078ae54 100644
--- a/spec/ruby/core/module/shared/class_eval.rb
+++ b/spec/ruby/core/module/shared/class_eval.rb
@@ -112,4 +112,48 @@ describe :module_class_eval, shared: true do
     a.attribute.should == "A"
     b.attribute.should == "B"
   end
+
+  it "activates refinements from the eval scope" do
+    refinery = Module.new do
+      refine ModuleSpecs::NamedClass do
+        def foo
+          "bar"
+        end
+      end
+    end
+
+    mid = @method
+    result = nil
+
+    Class.new do
+      using refinery
+
+      result = send(mid, "ModuleSpecs::NamedClass.new.foo")
+    end
+
+    result.should == "bar"
+  end
+
+  it "activates refinements from the eval scope with block" do
+    refinery = Module.new do
+      refine ModuleSpecs::NamedClass do
+        def foo
+          "bar"
+        end
+      end
+    end
+
+    mid = @method
+    result = nil
+
+    Class.new do
+      using refinery
+
+      result = send(mid) do
+        ModuleSpecs::NamedClass.new.foo
+      end
+    end
+
+    result.should == "bar"
+  end
 end
diff --git a/spec/ruby/core/nil/match_spec.rb b/spec/ruby/core/nil/match_spec.rb
index 3f69312bfe..27646e9749 100644
--- a/spec/ruby/core/nil/match_spec.rb
+++ b/spec/ruby/core/nil/match_spec.rb
@@ -15,5 +15,9 @@ ruby_version_is "2.6" do
         (o =~ true).should       be_nil
       end
     end
+
+    it "should not warn" do
+      -> { nil =~ /a/ }.should_not complain(verbose: true)
+    end
   end
 end
diff --git a/spec/ruby/core/string/shared/slice.rb b/spec/ruby/core/string/shared/slice.rb
index b192005369..1c438bc48d 100644
--- a/spec/ruby/core/string/shared/slice.rb
+++ b/spec/ruby/core/string/shared/slice.rb
@@ -121,6 +121,8 @@ describe :string_slice_index_length, shared: true do
 
     "x".send(@method, -2,0).should == nil
     "x".send(@method, -2,1).should == nil
+
+    "x".send(@method, fixnum_max, 1).should == nil
   end
 
   it "returns nil if the length is negative" do
@@ -293,6 +295,24 @@ describe :string_slice_range, shared: true do
     "hello world".send(@method, 6..5).send(@method, -1..-1).should == nil
     "hello world".send(@method, 6..5).send(@method, 1..1).should == nil
   end
+
+  it "raises a type error if a range is passed with a length" do
+    ->{ "hello".send(@method, 1..2, 1) }.should raise_error(TypeError)
+  end
+
+  it "raises a RangeError if one of the bound is too big" do
+    -> { "hello".send(@method, bignum_value..(bignum_value + 1)) }.should raise_error(RangeError)
+    -> { "hello".send(@method, 0..bignum_value) }.should raise_error(RangeError)
+  end
+
+  ruby_version_is "2.6" do
+    it "works with endless ranges" do
+      "hello there".send(@method, eval("(2..)")).should == "llo there"
+      "hello there".send(@method, eval("(2...)")).should == "llo there"
+      "hello there".send(@method, eval("(-4..)")).should == "here"
+      "hello there".send(@method, eval("(-4...)")).should == "here"
+    end
+  end
 end
 
 describe :string_slice_regexp, shared: true do
diff --git a/spec/ruby/core/struct/new_spec.rb b/spec/ruby/core/struct/new_spec.rb
index 564c49af01..071aa38d25 100644
--- a/spec/ruby/core/struct/new_spec.rb
+++ b/spec/ruby/core/struct/new_spec.rb
@@ -15,7 +15,7 @@ describe "Struct.new" do
     second = nil
     -> {
       second = Struct.new('Person', :hair, :sex)
-    }.should complain(/redefining constant/)
+    }.should complain(/constant/)
     second.should == Struct::Person
 
     first.members.should_not == second.members
diff --git a/spec/ruby/core/thread/backtrace_locations_spec.rb b/spec/ruby/core/thread/backtrace_locations_spec.rb
index 211858899c..ead4be2d8c 100644
--- a/spec/ruby/core/thread/backtrace_locations_spec.rb
+++ b/spec/ruby/core/thread/backtrace_locations_spec.rb
@@ -22,28 +22,33 @@ describe "Thread#backtrace_locations" do
   it "can be called with a number of locations to omit" do
     locations1 = Thread.current.backtrace_locations
     locations2 = Thread.current.backtrace_locations(2)
-    locations1[2..-1].length.should == locations2.length
-    locations1[2..-1].map(&:to_s).should == locations2.map(&:to_s)
+    locations2.length.should == locations1[2..-1].length
+    locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
   end
 
   it "can be called with a maximum number of locations to return as second parameter" do
     locations1 = Thread.current.backtrace_locations
     locations2 = Thread.current.backtrace_locations(2, 3)
-    locations1[2..4].map(&:to_s).should == locations2.map(&:to_s)
+    locations2.map(&:to_s).should == locations1[2..4].map(&:to_s)
   end
 
   it "can be called with a range" do
     locations1 = Thread.current.backtrace_locations
     locations2 = Thread.current.backtrace_locations(2..4)
-    locations1[2..4].map(&:to_s).should == locations2.map(&:to_s)
+    locations2.map(&:to_s).should == locations1[2..4].map(&:to_s)
   end
 
   it "can be called with a range whose end is negative" do
-    locations1 = Thread.current.backtrace_locations
-    locations2 = Thread.current.backtrace_locations(2..-1)
-    locations3 = Thread.current.backtrace_locations(2..-2)
-    locations1[2..-1].map(&:to_s).should == locations2.map(&:to_s)
-    locations1[2..-2].map(&:to_s).should == locations3.map(&:to_s)
+    Thread.current.backtrace_locations(2..-1).map(&:to_s).should == Thread.current.backtrace_locations[2..-1].map(&:to_s)
+    Thread.current.backtrace_locations(2..-2).map(&:to_s).should == Thread.current.backtrace_locations[2..-2].map(&:to_s)
+  end
+
+  ruby_version_is "2.6" do
+    it "can be called with an endless range" do
+      locations1 = Thread.current.backtrace_locations(0)
+      locations2 = Thread.current.backtrace_locations(eval("(2..)"))
+      locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
+    end
   end
 
   it "returns nil if omitting more locations than available" do
diff --git a/spec/ruby/core/thread/backtrace_spec.rb b/spec/ruby/core/thread/backtrace_spec.rb
index 84ed574d5c..9001b1b7eb 100644
--- a/spec/ruby/core/thread/backtrace_spec.rb
+++ b/spec/ruby/core/thread/backtrace_spec.rb
@@ -32,4 +32,38 @@ describe "Thread#backtrace" do
     t.join
     backtrace.should be_kind_of(Array)
   end
+
+  it "can be called with a number of locations to omit" do
+    locations1 = Thread.current.backtrace
+    locations2 = Thread.current.backtrace(2)
+    locations1[2..-1].length.should == locations2.length
+    locations1[2..-1].map(&:to_s).should == locations2.map(&:to_s)
+  end
+
+  it "can be called with a maximum number of locations to return as second parameter" do
+    locations1 = Thread.current.backtrace
+    locations2 = Thread.current.backtrace(2, 3)
+    locations1[2..4].map(&:to_s).should == locations2.map(&:to_s)
+  end
+
+  it "can be called with a range" do
+    locations1 = Thread.current.backtrace
+    locations2 = Thread.current.backtrace(2..4)
+    locations1[2..4].map(&:to_s).should == locations2.map(&:to_s)
+  end
+
+  it "can be called with a range whose end is negative" do
+    Thread.current.backtrace(2..-1).should == Thread.current.backtrace[2..-1]
+    Thread.current.backtrace(2..-2).should == Thread.current.backtrace[2..-2]
+  end
+
+  it "returns nil if omitting more locations than available" do
+    Thread.current.backtrace(100).should == nil
+    Thread.current.backtrace(100..-1).should == nil
+  end
+
+  it "returns [] if omitting exactly the number of locations available" do
+    omit = Thread.current.backtrace.length
+    Thread.current.backtrace(omit).should == []
+  end
 end
diff --git a/spec/ruby/core/time/ceil_spec.rb b/spec/ruby/core/time/ceil_spec.rb
index 29dcec5d72..86029554db 100644
--- a/spec/ruby/core/time/ceil_spec.rb
+++ b/spec/ruby/core/time/ceil_spec.rb
@@ -36,10 +36,11 @@ ruby_version_is "2.7" do
     it "copies own timezone to the returning value" do
       @time.zone.should == @time.ceil.zone
 
-      with_timezone "JST-9" do
-        time = Time.at 0, 1
-        time.zone.should == time.ceil.zone
+      time = with_timezone "JST-9" do
+        Time.at 0, 1
       end
+
+      time.zone.should == time.ceil.zone
     end
   end
 end
diff --git a/spec/ruby/core/time/floor_spec.rb b/spec/ruby/core/time/floor_spec.rb
index 763ed1ba51..a19585b787 100644
--- a/spec/ruby/core/time/floor_spec.rb
+++ b/spec/ruby/core/time/floor_spec.rb
@@ -28,10 +28,11 @@ ruby_version_is "2.7" do
     it "copies own timezone to the returning value" do
       @time.zone.should == @time.floor.zone
 
-      with_timezone "JST-9" do
-        time = Time.at 0, 1
-        time.zone.should == time.floor.zone
+      time = with_timezone "JST-9" do
+        Time.at 0, 1
       end
+
+      time.zone.should == time.floor.zone
     end
   end
 end