1 files changed, 30 insertions, 72 deletions
diff --git a/spec/ruby/core/numeric/step_spec.rb b/spec/ruby/core/numeric/step_spec.rb
index 256c150d4e..6896009eb6 100644
--- a/spec/ruby/core/numeric/step_spec.rb
+++ b/spec/ruby/core/numeric/step_spec.rb
@@ -1,67 +1,46 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes', __FILE__)
-require File.expand_path('../shared/step', __FILE__)
+require_relative '../../spec_helper'
+require_relative 'fixtures/classes'
+require_relative 'shared/step'
 
 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(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(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
-      it "returns an Enumerator when step is 0" do
-        1.step(5, 0).should be_an_instance_of(Enumerator)
-      end
-
-      it "returns an Enumerator when step is 0.0" do
-        1.step(2, 0.0).should be_an_instance_of(Enumerator)
-      end
+      step_enum_class = Enumerator::ArithmeticSequence
 
-      describe "returned Enumerator" do
+      describe "returned #{step_enum_class}" do
         describe "size" do
-          it "raises an ArgumentError when step is 0" do
-            enum = 1.step(5, 0)
-            lambda { enum.size }.should raise_error(ArgumentError)
+          it "defaults to an infinite size" do
+            enum = 1.step
+            enum.size.should == Float::INFINITY
           end
+        end
 
-          it "raises an ArgumentError when step is 0.0" do
-            enum = 1.step(2, 0.0)
-            lambda { enum.size }.should raise_error(ArgumentError)
+        describe "type" do
+          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
@@ -69,19 +48,11 @@ 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
 
-          it "should return infinity_value when decending towards a limit of -Float::INFINITY" do
+          it "should return infinity_value when descending towards a limit of -Float::INFINITY" do
             1.step(to: -Float::INFINITY, by: -42).size.should == infinity_value
           end
 
@@ -97,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(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(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(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(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