From f3b347e109f42f53ffc30f9e6e10be4b4f285916 Mon Sep 17 00:00:00 2001 From: eregon Date: Fri, 17 Aug 2018 11:22:30 +0000 Subject: Add version guards for Enumerator::ArithmeticSequence * And keep specs for older versions. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@64411 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- spec/ruby/core/numeric/shared/step.rb | 19 +++++++++------ spec/ruby/core/numeric/step_spec.rb | 41 +++++++++++++++++++++++--------- spec/ruby/core/range/step_spec.rb | 44 ++++++++++++++++++++++++++++------- 3 files changed, 77 insertions(+), 27 deletions(-) (limited to 'spec/ruby/core') diff --git a/spec/ruby/core/numeric/shared/step.rb b/spec/ruby/core/numeric/shared/step.rb index f058c64a50..0fb2336bf5 100644 --- a/spec/ruby/core/numeric/shared/step.rb +++ b/spec/ruby/core/numeric/shared/step.rb @@ -258,19 +258,24 @@ describe :numeric_step, :shared => true do end describe "when no block is given" do - it "returns an Enumerator when step is 0" do - 1.send(@method, *@step_args.call(2, 0)).should be_an_instance_of(Enumerator::ArithmeticSequence) + step_enum_class = Enumerator + ruby_version_is "2.6" do + step_enum_class = Enumerator::ArithmeticSequence end - it "returns an Enumerator when not passed a block and self > stop" do - 1.send(@method, *@step_args.call(0, 2)).should be_an_instance_of(Enumerator::ArithmeticSequence) + it "returns an #{step_enum_class} when step is 0" do + 1.send(@method, *@step_args.call(2, 0)).should be_an_instance_of(step_enum_class) end - it "returns an Enumerator when not passed a block and self < stop" do - 1.send(@method, *@step_args.call(2, 3)).should be_an_instance_of(Enumerator::ArithmeticSequence) + it "returns an #{step_enum_class} when not passed a block and self > stop" do + 1.send(@method, *@step_args.call(0, 2)).should be_an_instance_of(step_enum_class) end - it "returns an Enumerator that uses the given step" do + it "returns an #{step_enum_class} when not passed a block and self < stop" do + 1.send(@method, *@step_args.call(2, 3)).should be_an_instance_of(step_enum_class) + end + + it "returns an #{step_enum_class} that uses the given step" do 0.send(@method, *@step_args.call(5, 2)).to_a.should eql [0, 2, 4] end diff --git a/spec/ruby/core/numeric/step_spec.rb b/spec/ruby/core/numeric/step_spec.rb index 54133f8810..1eb91aa1e5 100644 --- a/spec/ruby/core/numeric/step_spec.rb +++ b/spec/ruby/core/numeric/step_spec.rb @@ -22,24 +22,43 @@ describe "Numeric#step" do 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::ArithmeticSequence) + step_enum_class = Enumerator + ruby_version_is "2.6" do + step_enum_class = Enumerator::ArithmeticSequence end - it "returns an Enumerator when step is 0.0" do - 1.step(2, 0.0).should be_an_instance_of(Enumerator::ArithmeticSequence) + it "returns an #{step_enum_class} when step is 0" do + 1.step(5, 0).should be_an_instance_of(step_enum_class) end - describe "returned Enumerator" do + 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 + + describe "returned #{step_enum_class}" do describe "size" do - it "raises an ArgumentError when step is 0" do - enum = 1.step(5, 0) - enum.size.should == Float::INFINITY + 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 - it "raises an ArgumentError when step is 0.0" do - enum = 1.step(2, 0.0) - enum.size.should == Float::INFINITY + 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 end end diff --git a/spec/ruby/core/range/step_spec.rb b/spec/ruby/core/range/step_spec.rb index c364600fb0..cdf66e4565 100644 --- a/spec/ruby/core/range/step_spec.rb +++ b/spec/ruby/core/range/step_spec.rb @@ -1,13 +1,18 @@ require_relative '../../spec_helper' describe "Range#step" do + step_enum_class = Enumerator + ruby_version_is "2.6" do + step_enum_class = Enumerator::ArithmeticSequence + end + before :each do ScratchPad.record [] end - it "returns an arithmetic sequence when no block is given" do + it "returns an #{step_enum_class} when no block is given" do enum = (1..10).step(4) - enum.should be_an_instance_of(Enumerator::ArithmeticSequence) + enum.should be_an_instance_of(step_enum_class) enum.to_a.should eql([1, 5, 9]) end @@ -263,7 +268,7 @@ describe "Range#step" do end describe "when no block is given" do - describe "returned Enumerator::ArithmeticSequence" do + describe "returned #{step_enum_class}" do describe "size" do it "raises a TypeError if step does not respond to #to_int" do obj = mock("Range#step non-integer") @@ -279,9 +284,28 @@ describe "Range#step" do lambda { enum.size }.should raise_error(TypeError) end - it "returns Float::INFINITY for zero step" do - (-1..1).step(0).size.should == Float::INFINITY - (-1..1).step(0.0).size.should == Float::INFINITY + ruby_version_is ""..."2.6" do + it "raises an ArgumentError if step is 0" do + enum = (-1..1).step(0) + lambda { enum.size }.should raise_error(ArgumentError) + end + + it "raises an ArgumentError if step is 0.0" do + enum = (-1..1).step(0.0) + lambda { enum.size }.should raise_error(ArgumentError) + end + + it "raises an ArgumentError if step is negative" do + enum = (-1..1).step(-2) + lambda { enum.size }.should raise_error(ArgumentError) + end + end + + ruby_version_is "2.6" do + it "returns Float::INFINITY for zero step" do + (-1..1).step(0).size.should == Float::INFINITY + (-1..1).step(0.0).size.should == Float::INFINITY + end end it "returns the ceil of range size divided by the number of steps" do @@ -297,9 +321,11 @@ describe "Range#step" do (-5...5).step(2).size.should == 5 end - it "returns the ceil of range size divided by the number of steps even if step is negative" do - (-1..1).step(-1).size.should == 0 - (1..-1).step(-1).size.should == 3 + ruby_version_is "2.6" do + it "returns the ceil of range size divided by the number of steps even if step is negative" do + (-1..1).step(-1).size.should == 0 + (1..-1).step(-1).size.should == 3 + end end it "returns the correct number of steps when one of the arguments is a float" do -- cgit v1.2.3