1 files changed, 58 insertions, 41 deletions
diff --git a/spec/ruby/core/string/shared/slice.rb b/spec/ruby/core/string/shared/slice.rb
index 2f69b9ddce..d296ab6680 100644
--- a/spec/ruby/core/string/shared/slice.rb
+++ b/spec/ruby/core/string/shared/slice.rb
@@ -21,17 +21,17 @@ describe :string_slice, shared: true do
   end
 
   it "raises a TypeError if the given index is nil" do
-    -> { "hello".send(@method, nil) }.should raise_error(TypeError)
+    -> { "hello".send(@method, nil) }.should.raise(TypeError)
   end
 
   it "raises a TypeError if the given index can't be converted to an Integer" do
-    -> { "hello".send(@method, mock('x')) }.should raise_error(TypeError)
-    -> { "hello".send(@method, {})        }.should raise_error(TypeError)
-    -> { "hello".send(@method, [])        }.should raise_error(TypeError)
+    -> { "hello".send(@method, mock('x')) }.should.raise(TypeError)
+    -> { "hello".send(@method, {})        }.should.raise(TypeError)
+    -> { "hello".send(@method, [])        }.should.raise(TypeError)
   end
 
   it "raises a RangeError if the index is too big" do
-    -> { "hello".send(@method, bignum_value) }.should raise_error(RangeError)
+    -> { "hello".send(@method, bignum_value) }.should.raise(RangeError)
   end
 end
 
@@ -119,6 +119,18 @@ describe :string_slice_index_length, shared: true do
     "hello there".send(@method, -4,-3).should == nil
   end
 
+  platform_is pointer_size: 64 do
+    it "returns nil if the length is negative big value" do
+      "hello there".send(@method, 4, -(1 << 31)).should == nil
+
+      # by some reason length < -(1 << 31) on CI on Windows leads to
+      # 'RangeError: bignum too big to convert into `long'' error
+      platform_is_not :windows do
+        "hello there".send(@method, 4, -(1 << 63)).should == nil
+      end
+    end
+  end
+
   it "calls to_int on the given index and the given length" do
     "hello".send(@method, 0.5, 1).should == "h"
     "hello".send(@method, 0.5, 2.5).should == "he"
@@ -133,30 +145,35 @@ describe :string_slice_index_length, shared: true do
   end
 
   it "raises a TypeError when idx or length can't be converted to an integer" do
-    -> { "hello".send(@method, mock('x'), 0) }.should raise_error(TypeError)
-    -> { "hello".send(@method, 0, mock('x')) }.should raise_error(TypeError)
+    -> { "hello".send(@method, mock('x'), 0) }.should.raise(TypeError)
+    -> { "hello".send(@method, 0, mock('x')) }.should.raise(TypeError)
 
     # I'm deliberately including this here.
     # It means that str.send(@method, other, idx) isn't supported.
-    -> { "hello".send(@method, "", 0) }.should raise_error(TypeError)
+    -> { "hello".send(@method, "", 0) }.should.raise(TypeError)
   end
 
   it "raises a TypeError when the given index or the given length is nil" do
-    -> { "hello".send(@method, 1, nil)   }.should raise_error(TypeError)
-    -> { "hello".send(@method, nil, 1)   }.should raise_error(TypeError)
-    -> { "hello".send(@method, nil, nil) }.should raise_error(TypeError)
+    -> { "hello".send(@method, 1, nil)   }.should.raise(TypeError)
+    -> { "hello".send(@method, nil, 1)   }.should.raise(TypeError)
+    -> { "hello".send(@method, nil, nil) }.should.raise(TypeError)
   end
 
   it "raises a RangeError if the index or length is too big" do
-    -> { "hello".send(@method, bignum_value, 1) }.should raise_error(RangeError)
-    -> { "hello".send(@method, 0, bignum_value) }.should raise_error(RangeError)
+    -> { "hello".send(@method, bignum_value, 1) }.should.raise(RangeError)
+    -> { "hello".send(@method, 0, bignum_value) }.should.raise(RangeError)
+  end
+
+  it "raises a RangeError if the index or length is too small" do
+    -> { "hello".send(@method, -bignum_value, 1) }.should.raise(RangeError)
+    -> { "hello".send(@method, 0, -bignum_value) }.should.raise(RangeError)
   end
 
   it "returns String instances" do
     s = StringSpecs::MyString.new("hello")
-    s.send(@method, 0,0).should be_an_instance_of(String)
-    s.send(@method, 0,4).should be_an_instance_of(String)
-    s.send(@method, 1,4).should be_an_instance_of(String)
+    s.send(@method, 0,0).should.instance_of?(String)
+    s.send(@method, 0,4).should.instance_of?(String)
+    s.send(@method, 1,4).should.instance_of?(String)
   end
 
   it "handles repeated application" do
@@ -233,9 +250,9 @@ describe :string_slice_range, shared: true do
 
   it "returns String instances" do
     s = StringSpecs::MyString.new("hello")
-    s.send(@method, 0...0).should be_an_instance_of(String)
-    s.send(@method, 0..4).should be_an_instance_of(String)
-    s.send(@method, 1..4).should be_an_instance_of(String)
+    s.send(@method, 0...0).should.instance_of?(String)
+    s.send(@method, 0..4).should.instance_of?(String)
+    s.send(@method, 1..4).should.instance_of?(String)
   end
 
   it "calls to_int on range arguments" do
@@ -276,12 +293,12 @@ describe :string_slice_range, shared: true do
   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)
+    ->{ "hello".send(@method, 1..2, 1) }.should.raise(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)
+    -> { "hello".send(@method, bignum_value..(bignum_value + 1)) }.should.raise(RangeError)
+    -> { "hello".send(@method, 0..bignum_value) }.should.raise(RangeError)
   end
 
   it "works with endless ranges" do
@@ -316,8 +333,8 @@ describe :string_slice_regexp, shared: true do
 
   it "returns String instances" do
     s = StringSpecs::MyString.new("hello")
-    s.send(@method, //).should be_an_instance_of(String)
-    s.send(@method, /../).should be_an_instance_of(String)
+    s.send(@method, //).should.instance_of?(String)
+    s.send(@method, /../).should.instance_of?(String)
   end
 
   it "sets $~ to MatchData when there is a match and nil when there's none" do
@@ -377,19 +394,19 @@ describe :string_slice_regexp_index, shared: true do
   end
 
   it "raises a TypeError when the given index can't be converted to Integer" do
-    -> { "hello".send(@method, /(.)(.)(.)/, mock('x')) }.should raise_error(TypeError)
-    -> { "hello".send(@method, /(.)(.)(.)/, {})        }.should raise_error(TypeError)
-    -> { "hello".send(@method, /(.)(.)(.)/, [])        }.should raise_error(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, mock('x')) }.should.raise(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, {})        }.should.raise(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, [])        }.should.raise(TypeError)
   end
 
   it "raises a TypeError when the given index is nil" do
-    -> { "hello".send(@method, /(.)(.)(.)/, nil) }.should raise_error(TypeError)
+    -> { "hello".send(@method, /(.)(.)(.)/, nil) }.should.raise(TypeError)
   end
 
   it "returns String instances" do
     s = StringSpecs::MyString.new("hello")
-    s.send(@method, /(.)(.)/, 0).should be_an_instance_of(String)
-    s.send(@method, /(.)(.)/, 1).should be_an_instance_of(String)
+    s.send(@method, /(.)(.)/, 0).should.instance_of?(String)
+    s.send(@method, /(.)(.)/, 1).should.instance_of?(String)
   end
 
   it "sets $~ to MatchData when there is a match and nil when there's none" do
@@ -425,14 +442,14 @@ describe :string_slice_string, shared: true do
     o = mock('x')
     o.should_not_receive(:to_str)
 
-    -> { "hello".send(@method, o) }.should raise_error(TypeError)
+    -> { "hello".send(@method, o) }.should.raise(TypeError)
   end
 
   it "returns a String instance when given a subclass instance" do
     s = StringSpecs::MyString.new("el")
     r = "hello".send(@method, s)
     r.should == "el"
-    r.should be_an_instance_of(String)
+    r.should.instance_of?(String)
   end
 end
 
@@ -459,28 +476,28 @@ describe :string_slice_regexp_group, shared: true do
     end
 
     it "returns nil if there is no match" do
-      "hello there".send(@method, /(?<whut>what?)/, 'whut').should be_nil
+      "hello there".send(@method, /(?<whut>what?)/, 'whut').should == nil
     end
 
     it "raises an IndexError if there is no capture for the given name" do
       -> do
         "hello there".send(@method, /[aeiou](.)\1/, 'non')
-      end.should raise_error(IndexError)
+      end.should.raise(IndexError)
     end
 
     it "raises a TypeError when the given name is not a String" do
-      -> { "hello".send(@method, /(?<q>.)/, mock('x')) }.should raise_error(TypeError)
-      -> { "hello".send(@method, /(?<q>.)/, {})        }.should raise_error(TypeError)
-      -> { "hello".send(@method, /(?<q>.)/, [])        }.should raise_error(TypeError)
+      -> { "hello".send(@method, /(?<q>.)/, mock('x')) }.should.raise(TypeError)
+      -> { "hello".send(@method, /(?<q>.)/, {})        }.should.raise(TypeError)
+      -> { "hello".send(@method, /(?<q>.)/, [])        }.should.raise(TypeError)
     end
 
     it "raises an IndexError when given the empty String as a group name" do
-      -> { "hello".send(@method, /(?<q>)/, '') }.should raise_error(IndexError)
+      -> { "hello".send(@method, /(?<q>)/, '') }.should.raise(IndexError)
     end
 
     it "returns String instances" do
       s = StringSpecs::MyString.new("hello")
-      s.send(@method, /(?<q>.)/, 'q').should be_an_instance_of(String)
+      s.send(@method, /(?<q>.)/, 'q').should.instance_of?(String)
     end
 
     it "sets $~ to MatchData when there is a match and nil when there's none" do
@@ -488,13 +505,13 @@ describe :string_slice_regexp_group, shared: true do
       $~[0].should == 'he'
 
       'hello'.send(@method, /(?<non>not)/, 'non')
-      $~.should be_nil
+      $~.should == nil
     end
   end
 end
 
 describe :string_slice_symbol, shared: true do
   it "raises TypeError" do
-    -> { 'hello'.send(@method, :hello) }.should raise_error(TypeError)
+    -> { 'hello'.send(@method, :hello) }.should.raise(TypeError)
   end
 end