1 files changed, 20 insertions, 100 deletions
diff --git a/spec/ruby/core/numeric/step_spec.rb b/spec/ruby/core/numeric/step_spec.rb
index 12369a47a2..1705fb1b4e 100644
--- a/spec/ruby/core/numeric/step_spec.rb
+++ b/spec/ruby/core/numeric/step_spec.rb
@@ -6,61 +6,25 @@ describe "Numeric#step" do
 
   describe 'with positional args' do
     it "raises an ArgumentError when step is 0" do
-      lambda { 1.step(5, 0) {} }.should raise_error(ArgumentError)
+      -> { 1.step(5, 0) {} }.should raise_error(ArgumentError)
     end
 
     it "raises an ArgumentError when step is 0.0" do
-      lambda { 1.step(2, 0.0) {} }.should raise_error(ArgumentError)
+      -> { 1.step(2, 0.0) {} }.should raise_error(ArgumentError)
     end
 
     before :all do
       # This lambda definition limits to return the arguments it receives.
       # It's needed to test numeric_step behaviour with positional arguments.
-      @step_args = ->(*args) { args }
+      @step = -> receiver, *args, &block { receiver.step(*args, &block) }
     end
-
     it_behaves_like :numeric_step, :step
 
     describe "when no block is given" do
-      step_enum_class = Enumerator
-      ruby_version_is "2.6" do
-        step_enum_class = Enumerator::ArithmeticSequence
-      end
-
-      it "returns an #{step_enum_class} when step is 0" do
-        1.step(5, 0).should be_an_instance_of(step_enum_class)
-      end
-
-      it "returns an #{step_enum_class} when step is 0.0" do
-        1.step(2, 0.0).should be_an_instance_of(step_enum_class)
-      end
+      step_enum_class = Enumerator::ArithmeticSequence
 
       describe "returned #{step_enum_class}" do
         describe "size" do
-          ruby_version_is ""..."2.6" do
-            it "raises an ArgumentError when step is 0" do
-              enum = 1.step(5, 0)
-              lambda { enum.size }.should raise_error(ArgumentError)
-            end
-
-            it "raises an ArgumentError when step is 0.0" do
-              enum = 1.step(2, 0.0)
-              lambda { enum.size }.should raise_error(ArgumentError)
-            end
-          end
-
-          ruby_version_is "2.6" do
-            it "is infinity when step is 0" do
-              enum = 1.step(5, 0)
-              enum.size.should == Float::INFINITY
-            end
-
-            it "is infinity when step is 0.0" do
-              enum = 1.step(2, 0.0)
-              enum.size.should == Float::INFINITY
-            end
-          end
-
           it "defaults to an infinite size" do
             enum = 1.step
             enum.size.should == Float::INFINITY
@@ -68,38 +32,15 @@ describe "Numeric#step" do
         end
 
         describe "type" do
-          ruby_version_is ""..."2.6" do
-            it "returns an instance of Enumerator" do
-              1.step(10).class.should == Enumerator
-            end
-          end
-
-          ruby_version_is "2.6" do
-            it "returns an instance of Enumerator::ArithmeticSequence" do
-              1.step(10).class.should == Enumerator::ArithmeticSequence
-            end
+          it "returns an instance of Enumerator::ArithmeticSequence" do
+            1.step(10).class.should == Enumerator::ArithmeticSequence
           end
         end
       end
     end
-
   end
 
   describe 'with keyword arguments' do
-    it "doesn't raise an error when step is 0" do
-      lambda { 1.step(to: 5, by: 0) { break } }.should_not raise_error
-    end
-
-    it "doesn't raise an error when step is 0.0" do
-      lambda { 1.step(to: 2, by: 0.0) { break } }.should_not raise_error
-    end
-
-    it "should loop over self when step is 0 or 0.0" do
-      1.step(to: 2, by: 0.0).take(5).should eql [1.0, 1.0, 1.0, 1.0, 1.0]
-      1.step(to: 2, by: 0).take(5).should eql [1, 1, 1, 1, 1]
-      1.1.step(to: 2, by: 0).take(5).should eql [1.1, 1.1, 1.1, 1.1, 1.1]
-    end
-
     describe "when no block is given" do
       describe "returned Enumerator" do
         describe "size" do
@@ -107,14 +48,6 @@ describe "Numeric#step" do
             1.step(by: 42).size.should == infinity_value
           end
 
-          it "should return infinity_value when step is 0" do
-            1.step(to: 5, by: 0).size.should == infinity_value
-          end
-
-          it "should return infinity_value when step is 0.0" do
-            1.step(to: 2, by: 0.0).size.should == infinity_value
-          end
-
           it "should return infinity_value when ascending towards a limit of Float::INFINITY" do
             1.step(to: Float::INFINITY, by: 42).size.should == infinity_value
           end
@@ -135,64 +68,51 @@ describe "Numeric#step" do
     end
 
     before :all do
-      # This lambda transforms a positional step method args into
-      # keyword arguments.
+      # This lambda transforms a positional step method args into  keyword arguments.
       # It's needed to test numeric_step behaviour with keyword arguments.
-      @step_args = ->(*args) do
-        kw_args = {to: args[0]}
+      @step = -> receiver, *args, &block do
+        kw_args = { to: args[0] }
         kw_args[:by] = args[1] if args.size == 2
-        [kw_args]
+        receiver.step(**kw_args, &block)
       end
     end
     it_behaves_like :numeric_step, :step
   end
 
   describe 'with mixed arguments' do
-    it "doesn't raise an error when step is 0" do
-      lambda { 1.step(5, by: 0) { break } }.should_not raise_error
+    it " raises an ArgumentError when step is 0" do
+      -> { 1.step(5, by: 0) { break } }.should raise_error(ArgumentError)
     end
 
-    it "doesn't raise an error when step is 0.0" do
-      lambda { 1.step(2, by: 0.0) { break } }.should_not raise_error
+    it "raises an ArgumentError when step is 0.0" do
+      -> { 1.step(2, by: 0.0) { break } }.should raise_error(ArgumentError)
     end
 
     it "raises a ArgumentError when limit and to are defined" do
-      lambda { 1.step(5, 1, to: 5) { break } }.should raise_error(ArgumentError)
+      -> { 1.step(5, 1, to: 5) { break } }.should raise_error(ArgumentError)
     end
 
     it "raises a ArgumentError when step and by are defined" do
-      lambda { 1.step(5, 1, by: 5) { break } }.should raise_error(ArgumentError)
-    end
-
-    it "should loop over self when step is 0 or 0.0" do
-      1.step(2, by: 0.0).take(5).should eql [1.0, 1.0, 1.0, 1.0, 1.0]
-      1.step(2, by: 0).take(5).should eql [1, 1, 1, 1, 1]
-      1.1.step(2, by: 0).take(5).should eql [1.1, 1.1, 1.1, 1.1, 1.1]
+      -> { 1.step(5, 1, by: 5) { break } }.should raise_error(ArgumentError)
     end
 
     describe "when no block is given" do
       describe "returned Enumerator" do
         describe "size" do
-          it "should return infinity_value when step is 0" do
-            1.step(5, by: 0).size.should == infinity_value
-          end
-
-          it "should return infinity_value when step is 0.0" do
-            1.step(2, by: 0.0).size.should == infinity_value
-          end
         end
       end
     end
+
     before :all do
       # This lambda definition transforms a positional step method args into
       # a mix of positional and keyword arguments.
       # It's needed to test numeric_step behaviour with positional mixed with
       # keyword arguments.
-      @step_args = ->(*args) do
+      @step = -> receiver, *args, &block do
         if args.size == 2
-          [args[0], {by: args[1]}]
+          receiver.step(args[0], by: args[1], &block)
         else
-          args
+          receiver.step(*args, &block)
         end
       end
     end