1 files changed, 25 insertions, 25 deletions

diff --git a/spec/ruby/core/array/fill_spec.rb b/spec/ruby/core/array/fill_spec.rb
index 2c3b5d9e84..e4d51bd998 100644
--- a/spec/ruby/core/array/fill_spec.rb
+++ b/spec/ruby/core/array/fill_spec.rb
@@ -10,7 +10,7 @@ describe "Array#fill" do
 
   it "returns self" do
     ary = [1, 2, 3]
-    ary.fill(:a).should equal(ary)
+    ary.fill(:a).should.equal?(ary)
   end
 
   it "is destructive" do
@@ -25,10 +25,10 @@ describe "Array#fill" do
     ary.fill(str).should == [str, str, str, str]
     str << "y"
     ary.should == [str, str, str, str]
-    ary[0].should equal(str)
-    ary[1].should equal(str)
-    ary[2].should equal(str)
-    ary[3].should equal(str)
+    ary[0].should.equal?(str)
+    ary[1].should.equal?(str)
+    ary[2].should.equal?(str)
+    ary[3].should.equal?(str)
   end
 
   it "replaces all elements in the array with the filler if not given a index nor a length" do
@@ -44,29 +44,29 @@ describe "Array#fill" do
   end
 
   it "raises a FrozenError on a frozen array" do
-    -> { ArraySpecs.frozen_array.fill('x') }.should raise_error(FrozenError)
+    -> { ArraySpecs.frozen_array.fill('x') }.should.raise(FrozenError)
   end
 
   it "raises a FrozenError on an empty frozen array" do
-    -> { ArraySpecs.empty_frozen_array.fill('x') }.should raise_error(FrozenError)
+    -> { ArraySpecs.empty_frozen_array.fill('x') }.should.raise(FrozenError)
   end
 
   it "raises an ArgumentError if 4 or more arguments are passed when no block given" do
     [].fill('a').should == []
     [].fill('a', 1).should == []
     [].fill('a', 1, 2).should == [nil, 'a', 'a']
-    -> { [].fill('a', 1, 2, true) }.should raise_error(ArgumentError)
+    -> { [].fill('a', 1, 2, true) }.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError if no argument passed and no block given" do
-    -> { [].fill }.should raise_error(ArgumentError)
+    -> { [].fill }.should.raise(ArgumentError)
   end
 
   it "raises an ArgumentError if 3 or more arguments are passed when a block given" do
     [].fill() {|i|}.should == []
     [].fill(1) {|i|}.should == []
     [].fill(1, 2) {|i|}.should == [nil, nil, nil]
-    -> { [].fill(1, 2, true) {|i|} }.should raise_error(ArgumentError)
+    -> { [].fill(1, 2, true) {|i|} }.should.raise(ArgumentError)
   end
 
   it "does not truncate the array is the block raises an exception" do
@@ -237,24 +237,24 @@ describe "Array#fill with (filler, index, length)" do
   end
 
   it "raises a TypeError if the index is not numeric" do
-    -> { [].fill 'a', true }.should raise_error(TypeError)
+    -> { [].fill 'a', true }.should.raise(TypeError)
 
     obj = mock('nonnumeric')
-    -> { [].fill('a', obj) }.should raise_error(TypeError)
+    -> { [].fill('a', obj) }.should.raise(TypeError)
   end
 
   it "raises a TypeError when the length is not numeric" do
-    -> { [1, 2, 3].fill("x", 1, "foo") }.should raise_error(TypeError, /no implicit conversion of String into Integer/)
-    -> { [1, 2, 3].fill("x", 1, :"foo") }.should raise_error(TypeError, /no implicit conversion of Symbol into Integer/)
-    -> { [1, 2, 3].fill("x", 1, Object.new) }.should raise_error(TypeError, /no implicit conversion of Object into Integer/)
+    -> { [1, 2, 3].fill("x", 1, "foo") }.should.raise(TypeError, /no implicit conversion of String into Integer/)
+    -> { [1, 2, 3].fill("x", 1, :"foo") }.should.raise(TypeError, /no implicit conversion of Symbol into Integer/)
+    -> { [1, 2, 3].fill("x", 1, Object.new) }.should.raise(TypeError, /no implicit conversion of Object into Integer/)
   end
 
   not_supported_on :opal do
     it "raises an ArgumentError or RangeError for too-large sizes" do
       error_types = [RangeError, ArgumentError]
       arr = [1, 2, 3]
-      -> { arr.fill(10, 1, fixnum_max) }.should raise_error { |err| error_types.should include(err.class) }
-      -> { arr.fill(10, 1, bignum_value) }.should raise_error(RangeError)
+      -> { arr.fill(10, 1, fixnum_max) }.should.raise { |err| error_types.should.include?(err.class) }
+      -> { arr.fill(10, 1, bignum_value) }.should.raise(RangeError)
     end
   end
 end
@@ -284,7 +284,7 @@ describe "Array#fill with (filler, range)" do
   end
 
   it "raises a TypeError with range and length argument" do
-    -> { [].fill('x', 0 .. 2, 5) }.should raise_error(TypeError)
+    -> { [].fill('x', 0 .. 2, 5) }.should.raise(TypeError)
   end
 
   it "replaces elements between the (-m)th to the last and the (n+1)th from the first if given an range m..n where m < 0 and n >= 0" do
@@ -336,13 +336,13 @@ describe "Array#fill with (filler, range)" do
   end
 
   it "raises an exception if some of the given range lies before the first of the array" do
-    -> { [1, 2, 3].fill('x', -5..-3) }.should raise_error(RangeError)
-    -> { [1, 2, 3].fill('x', -5...-3) }.should raise_error(RangeError)
-    -> { [1, 2, 3].fill('x', -5..-4) }.should raise_error(RangeError)
+    -> { [1, 2, 3].fill('x', -5..-3) }.should.raise(RangeError)
+    -> { [1, 2, 3].fill('x', -5...-3) }.should.raise(RangeError)
+    -> { [1, 2, 3].fill('x', -5..-4) }.should.raise(RangeError)
 
-    -> { [1, 2, 3].fill(-5..-3, &@never_passed) }.should raise_error(RangeError)
-    -> { [1, 2, 3].fill(-5...-3, &@never_passed) }.should raise_error(RangeError)
-    -> { [1, 2, 3].fill(-5..-4, &@never_passed) }.should raise_error(RangeError)
+    -> { [1, 2, 3].fill(-5..-3, &@never_passed) }.should.raise(RangeError)
+    -> { [1, 2, 3].fill(-5...-3, &@never_passed) }.should.raise(RangeError)
+    -> { [1, 2, 3].fill(-5..-4, &@never_passed) }.should.raise(RangeError)
   end
 
   it "tries to convert the start and end of the passed range to Integers using #to_int" do
@@ -357,7 +357,7 @@ describe "Array#fill with (filler, range)" do
   it "raises a TypeError if the start or end of the passed range is not numeric" do
     obj = mock('nonnumeric')
     def obj.<=>(rhs); rhs == self ? 0 : nil end
-    -> { [].fill('a', obj..obj) }.should raise_error(TypeError)
+    -> { [].fill('a', obj..obj) }.should.raise(TypeError)
   end
 
   it "works with endless ranges" do