diff options
Diffstat (limited to 'spec/ruby/core')
112 files changed, 1884 insertions, 2237 deletions
diff --git a/spec/ruby/core/array/concat_spec.rb b/spec/ruby/core/array/concat_spec.rb index 985c5d884a..91adb8b745 100644 --- a/spec/ruby/core/array/concat_spec.rb +++ b/spec/ruby/core/array/concat_spec.rb @@ -110,23 +110,21 @@ describe "Array#concat" do ary.concat([5, 6]).should == [4, 5, 6] end - ruby_version_is "2.4" do - it "takes multiple arguments" do - ary = [1, 2] - ary.concat [3, 4] - ary.should == [1, 2, 3, 4] - end - - it "concatenates the initial value when given arguments contain 2 self" do - ary = [1, 2] - ary.concat ary, ary - ary.should == [1, 2, 1, 2, 1, 2] - end - - it "returns self when given no arguments" do - ary = [1, 2] - ary.concat.should equal(ary) - ary.should == [1, 2] - end + it "takes multiple arguments" do + ary = [1, 2] + ary.concat [3, 4] + ary.should == [1, 2, 3, 4] + end + + it "concatenates the initial value when given arguments contain 2 self" do + ary = [1, 2] + ary.concat ary, ary + ary.should == [1, 2, 1, 2, 1, 2] + end + + it "returns self when given no arguments" do + ary = [1, 2] + ary.concat.should equal(ary) + ary.should == [1, 2] end end diff --git a/spec/ruby/core/array/max_spec.rb b/spec/ruby/core/array/max_spec.rb index 5d0423d1e4..329b691883 100644 --- a/spec/ruby/core/array/max_spec.rb +++ b/spec/ruby/core/array/max_spec.rb @@ -1,10 +1,8 @@ require_relative '../../spec_helper' describe "Array#max" do - ruby_version_is "2.4" do - it "is defined on Array" do - [1].method(:max).owner.should equal Array - end + it "is defined on Array" do + [1].method(:max).owner.should equal Array end it "returns nil with no values" do diff --git a/spec/ruby/core/array/min_spec.rb b/spec/ruby/core/array/min_spec.rb index 903fa69bb8..22a179d808 100644 --- a/spec/ruby/core/array/min_spec.rb +++ b/spec/ruby/core/array/min_spec.rb @@ -1,10 +1,8 @@ require_relative '../../spec_helper' describe "Array#min" do - ruby_version_is "2.4" do - it "is defined on Array" do - [1].method(:max).owner.should equal Array - end + it "is defined on Array" do + [1].method(:max).owner.should equal Array end it "returns nil with no values" do diff --git a/spec/ruby/core/array/pack/buffer_spec.rb b/spec/ruby/core/array/pack/buffer_spec.rb index f2dc3e1930..28b317eacb 100644 --- a/spec/ruby/core/array/pack/buffer_spec.rb +++ b/spec/ruby/core/array/pack/buffer_spec.rb @@ -2,51 +2,49 @@ require_relative '../../../spec_helper' -ruby_version_is '2.4' do - describe "Array#pack with :buffer option" do - it "returns specified buffer" do - n = [ 65, 66, 67 ] - buffer = " "*3 - result = n.pack("ccc", buffer: buffer) #=> "ABC" - result.should equal(buffer) - end +describe "Array#pack with :buffer option" do + it "returns specified buffer" do + n = [ 65, 66, 67 ] + buffer = " "*3 + result = n.pack("ccc", buffer: buffer) #=> "ABC" + result.should equal(buffer) + end - it "adds result at the end of buffer content" do - n = [ 65, 66, 67 ] # result without buffer is "ABC" + it "adds result at the end of buffer content" do + n = [ 65, 66, 67 ] # result without buffer is "ABC" - buffer = "" - n.pack("ccc", buffer: buffer).should == "ABC" + buffer = "" + n.pack("ccc", buffer: buffer).should == "ABC" - buffer = "123" - n.pack("ccc", buffer: buffer).should == "123ABC" + buffer = "123" + n.pack("ccc", buffer: buffer).should == "123ABC" + + buffer = "12345" + n.pack("ccc", buffer: buffer).should == "12345ABC" + end - buffer = "12345" - n.pack("ccc", buffer: buffer).should == "12345ABC" + it "raises TypeError exception if buffer is not String" do + lambda { [65].pack("ccc", buffer: []) }.should raise_error( + TypeError, "buffer must be String, not Array") + end + + context "offset (@) is specified" do + it 'keeps buffer content if it is longer than offset' do + n = [ 65, 66, 67 ] + buffer = "123456" + n.pack("@3ccc", buffer: buffer).should == "123ABC" end - it "raises TypeError exception if buffer is not String" do - lambda { [65].pack("ccc", buffer: []) }.should raise_error( - TypeError, "buffer must be String, not Array") + it "fills the gap with \\0 if buffer content is shorter than offset" do + n = [ 65, 66, 67 ] + buffer = "123" + n.pack("@6ccc", buffer: buffer).should == "123\0\0\0ABC" end - context "offset (@) is specified" do - it 'keeps buffer content if it is longer than offset' do - n = [ 65, 66, 67 ] - buffer = "123456" - n.pack("@3ccc", buffer: buffer).should == "123ABC" - end - - it "fills the gap with \\0 if buffer content is shorter than offset" do - n = [ 65, 66, 67 ] - buffer = "123" - n.pack("@6ccc", buffer: buffer).should == "123\0\0\0ABC" - end - - it 'does not keep buffer content if it is longer than offset + result' do - n = [ 65, 66, 67 ] - buffer = "1234567890" - n.pack("@3ccc", buffer: buffer).should == "123ABC" - end + it 'does not keep buffer content if it is longer than offset + result' do + n = [ 65, 66, 67 ] + buffer = "1234567890" + n.pack("@3ccc", buffer: buffer).should == "123ABC" end end end diff --git a/spec/ruby/core/array/reject_spec.rb b/spec/ruby/core/array/reject_spec.rb index 8bce7ad3bf..6ae2581ff5 100644 --- a/spec/ruby/core/array/reject_spec.rb +++ b/spec/ruby/core/array/reject_spec.rb @@ -121,22 +121,20 @@ describe "Array#reject!" do a.should == [1, 2, 3] end - ruby_version_is "2.4" do - it "only removes elements for which the block returns true, keeping the element which raised an error." do - a = [1, 2, 3, 4] - begin - a.reject! do |x| - case x - when 2 then true - when 3 then raise StandardError, 'Oops' - else false - end + it "only removes elements for which the block returns true, keeping the element which raised an error." do + a = [1, 2, 3, 4] + begin + a.reject! do |x| + case x + when 2 then true + when 3 then raise StandardError, 'Oops' + else false end - rescue StandardError end - - a.should == [1, 3, 4] + rescue StandardError end + + a.should == [1, 3, 4] end it_behaves_like :enumeratorize, :reject! diff --git a/spec/ruby/core/array/sum_spec.rb b/spec/ruby/core/array/sum_spec.rb index 7d19c03480..a7e77d8c2e 100644 --- a/spec/ruby/core/array/sum_spec.rb +++ b/spec/ruby/core/array/sum_spec.rb @@ -1,44 +1,42 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "Array#sum" do - it "returns the sum of elements" do - [1, 2, 3].sum.should == 6 - end - - it "applies a block to each element before adding if it's given" do - [1, 2, 3].sum { |i| i * 10 }.should == 60 - end - - it "returns init value if array is empty" do - [].sum(-1).should == -1 - end - - it "returns 0 if array is empty and init is omitted" do - [].sum.should == 0 - end - - it "adds init value to the sum of elements" do - [1, 2, 3].sum(10).should == 16 - end - - it "can be used for non-numeric objects by providing init value" do - ["a", "b", "c"].sum("").should == "abc" - end - - it 'raises TypeError if any element are not numeric' do - lambda { ["a"].sum }.should raise_error(TypeError) - end - - it 'raises TypeError if any element cannot be added to init value' do - lambda { [1].sum([]) }.should raise_error(TypeError) - end - - it "calls + to sum the elements" do - a = mock("a") - b = mock("b") - a.should_receive(:+).with(b).and_return(42) - [b].sum(a).should == 42 - end +describe "Array#sum" do + it "returns the sum of elements" do + [1, 2, 3].sum.should == 6 + end + + it "applies a block to each element before adding if it's given" do + [1, 2, 3].sum { |i| i * 10 }.should == 60 + end + + it "returns init value if array is empty" do + [].sum(-1).should == -1 + end + + it "returns 0 if array is empty and init is omitted" do + [].sum.should == 0 + end + + it "adds init value to the sum of elements" do + [1, 2, 3].sum(10).should == 16 + end + + it "can be used for non-numeric objects by providing init value" do + ["a", "b", "c"].sum("").should == "abc" + end + + it 'raises TypeError if any element are not numeric' do + lambda { ["a"].sum }.should raise_error(TypeError) + end + + it 'raises TypeError if any element cannot be added to init value' do + lambda { [1].sum([]) }.should raise_error(TypeError) + end + + it "calls + to sum the elements" do + a = mock("a") + b = mock("b") + a.should_receive(:+).with(b).and_return(42) + [b].sum(a).should == 42 end end diff --git a/spec/ruby/core/basicobject/basicobject_spec.rb b/spec/ruby/core/basicobject/basicobject_spec.rb index 860ad93e89..ccaa9c8593 100644 --- a/spec/ruby/core/basicobject/basicobject_spec.rb +++ b/spec/ruby/core/basicobject/basicobject_spec.rb @@ -19,8 +19,12 @@ describe "BasicObject" do BasicObjectSpecs::BOSubclass.kernel_defined?.should be_nil end + it "is included in Object's list of constants" do + Object.constants(false).should include(:BasicObject) + end + it "includes itself in its list of constants" do - BasicObject.constants.should include(:BasicObject) + BasicObject.constants(false).should include(:BasicObject) end end diff --git a/spec/ruby/core/comparable/clamp_spec.rb b/spec/ruby/core/comparable/clamp_spec.rb index eb6a0838b9..d3f1022499 100644 --- a/spec/ruby/core/comparable/clamp_spec.rb +++ b/spec/ruby/core/comparable/clamp_spec.rb @@ -1,50 +1,48 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is '2.4' do - describe 'Comparable#clamp' do - it 'raises an Argument error unless given 2 parameters' do - c = ComparableSpecs::Weird.new(0) - lambda { c.clamp(c) }.should raise_error(ArgumentError) - lambda { c.clamp(c, c, c) }.should raise_error(ArgumentError) - end - - it 'raises an Argument error unless the 2 parameters are correctly ordered' do - one = ComparableSpecs::WithOnlyCompareDefined.new(1) - two = ComparableSpecs::WithOnlyCompareDefined.new(2) - c = ComparableSpecs::Weird.new(3) - - lambda { c.clamp(two, one) }.should raise_error(ArgumentError) - one.should_receive(:<=>).any_number_of_times.and_return(nil) - lambda { c.clamp(one, two) }.should raise_error(ArgumentError) - end - - it 'returns self if within the given parameters' do - one = ComparableSpecs::WithOnlyCompareDefined.new(1) - two = ComparableSpecs::WithOnlyCompareDefined.new(2) - three = ComparableSpecs::WithOnlyCompareDefined.new(3) - c = ComparableSpecs::Weird.new(2) - - c.clamp(one, two).should equal(c) - c.clamp(two, two).should equal(c) - c.clamp(one, three).should equal(c) - c.clamp(two, three).should equal(c) - end - - it 'returns the min parameter if smaller than it' do - one = ComparableSpecs::WithOnlyCompareDefined.new(1) - two = ComparableSpecs::WithOnlyCompareDefined.new(2) - c = ComparableSpecs::Weird.new(0) - - c.clamp(one, two).should equal(one) - end - - it 'returns the max parameter if greater than it' do - one = ComparableSpecs::WithOnlyCompareDefined.new(1) - two = ComparableSpecs::WithOnlyCompareDefined.new(2) - c = ComparableSpecs::Weird.new(3) - - c.clamp(one, two).should equal(two) - end +describe 'Comparable#clamp' do + it 'raises an Argument error unless given 2 parameters' do + c = ComparableSpecs::Weird.new(0) + lambda { c.clamp(c) }.should raise_error(ArgumentError) + lambda { c.clamp(c, c, c) }.should raise_error(ArgumentError) + end + + it 'raises an Argument error unless the 2 parameters are correctly ordered' do + one = ComparableSpecs::WithOnlyCompareDefined.new(1) + two = ComparableSpecs::WithOnlyCompareDefined.new(2) + c = ComparableSpecs::Weird.new(3) + + lambda { c.clamp(two, one) }.should raise_error(ArgumentError) + one.should_receive(:<=>).any_number_of_times.and_return(nil) + lambda { c.clamp(one, two) }.should raise_error(ArgumentError) + end + + it 'returns self if within the given parameters' do + one = ComparableSpecs::WithOnlyCompareDefined.new(1) + two = ComparableSpecs::WithOnlyCompareDefined.new(2) + three = ComparableSpecs::WithOnlyCompareDefined.new(3) + c = ComparableSpecs::Weird.new(2) + + c.clamp(one, two).should equal(c) + c.clamp(two, two).should equal(c) + c.clamp(one, three).should equal(c) + c.clamp(two, three).should equal(c) + end + + it 'returns the min parameter if smaller than it' do + one = ComparableSpecs::WithOnlyCompareDefined.new(1) + two = ComparableSpecs::WithOnlyCompareDefined.new(2) + c = ComparableSpecs::Weird.new(0) + + c.clamp(one, two).should equal(one) + end + + it 'returns the max parameter if greater than it' do + one = ComparableSpecs::WithOnlyCompareDefined.new(1) + two = ComparableSpecs::WithOnlyCompareDefined.new(2) + c = ComparableSpecs::Weird.new(3) + + c.clamp(one, two).should equal(two) end end diff --git a/spec/ruby/core/complex/finite_spec.rb b/spec/ruby/core/complex/finite_spec.rb index de4ba78246..718848390c 100644 --- a/spec/ruby/core/complex/finite_spec.rb +++ b/spec/ruby/core/complex/finite_spec.rb @@ -1,36 +1,32 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Complex#finite?" do - it "returns true if magnitude is finite" do - (1+1i).finite?.should == true - end +describe "Complex#finite?" do + it "returns true if magnitude is finite" do + (1+1i).finite?.should == true + end - it "returns false for positive infinity" do - value = Complex(Float::INFINITY, 42) - value.finite?.should == false - end + it "returns false for positive infinity" do + value = Complex(Float::INFINITY, 42) + value.finite?.should == false + end - it "returns false for positive complex with infinite imaginary" do - value = Complex(1, Float::INFINITY) - value.finite?.should == false - end + it "returns false for positive complex with infinite imaginary" do + value = Complex(1, Float::INFINITY) + value.finite?.should == false + end - it "returns false for negative infinity" do - value = -Complex(Float::INFINITY, 42) - value.finite?.should == false - end + it "returns false for negative infinity" do + value = -Complex(Float::INFINITY, 42) + value.finite?.should == false + end - it "returns false for negative complex with infinite imaginary" do - value = -Complex(1, Float::INFINITY) - value.finite?.should == false - end + it "returns false for negative complex with infinite imaginary" do + value = -Complex(1, Float::INFINITY) + value.finite?.should == false + end - ruby_bug "#14014", "2.4"..."2.5" do - it "returns false for NaN" do - value = Complex(Float::NAN, Float::NAN) - value.finite?.should == false - end - end + it "returns false for NaN" do + value = Complex(Float::NAN, Float::NAN) + value.finite?.should == false end end diff --git a/spec/ruby/core/complex/infinite_spec.rb b/spec/ruby/core/complex/infinite_spec.rb index 27aa038cd2..9e48860dee 100644 --- a/spec/ruby/core/complex/infinite_spec.rb +++ b/spec/ruby/core/complex/infinite_spec.rb @@ -1,34 +1,32 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Complex#infinite?" do - it "returns nil if magnitude is finite" do - (1+1i).infinite?.should == nil - end +describe "Complex#infinite?" do + it "returns nil if magnitude is finite" do + (1+1i).infinite?.should == nil + end - it "returns 1 for positive infinity" do - value = Complex(Float::INFINITY, 42).infinite? - value.should == 1 - end + it "returns 1 for positive infinity" do + value = Complex(Float::INFINITY, 42).infinite? + value.should == 1 + end - it "returns 1 for positive complex with infinite imaginary" do - value = Complex(1, Float::INFINITY).infinite? - value.should == 1 - end + it "returns 1 for positive complex with infinite imaginary" do + value = Complex(1, Float::INFINITY).infinite? + value.should == 1 + end - it "returns -1 for negative infinity" do - value = -Complex(Float::INFINITY, 42).infinite? - value.should == -1 - end + it "returns -1 for negative infinity" do + value = -Complex(Float::INFINITY, 42).infinite? + value.should == -1 + end - it "returns -1 for negative complex with infinite imaginary" do - value = -Complex(1, Float::INFINITY).infinite? - value.should == -1 - end + it "returns -1 for negative complex with infinite imaginary" do + value = -Complex(1, Float::INFINITY).infinite? + value.should == -1 + end - it "returns nil for NaN" do - value = Complex(0, Float::NAN).infinite? - value.should == nil - end + it "returns nil for NaN" do + value = Complex(0, Float::NAN).infinite? + value.should == nil end end diff --git a/spec/ruby/core/dir/empty_spec.rb b/spec/ruby/core/dir/empty_spec.rb index ddb955f816..626b228439 100644 --- a/spec/ruby/core/dir/empty_spec.rb +++ b/spec/ruby/core/dir/empty_spec.rb @@ -1,33 +1,31 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Dir.empty?" do - before :all do - @empty_dir = tmp("empty_dir") - mkdir_p @empty_dir - end +describe "Dir.empty?" do + before :all do + @empty_dir = tmp("empty_dir") + mkdir_p @empty_dir + end - after :all do - rm_r @empty_dir - end + after :all do + rm_r @empty_dir + end - it "returns true for empty directories" do - result = Dir.empty? @empty_dir - result.should be_true - end + it "returns true for empty directories" do + result = Dir.empty? @empty_dir + result.should be_true + end - it "returns false for non-empty directories" do - result = Dir.empty? __dir__ - result.should be_false - end + it "returns false for non-empty directories" do + result = Dir.empty? __dir__ + result.should be_false + end - it "returns false for a non-directory" do - result = Dir.empty? __FILE__ - result.should be_false - end + it "returns false for a non-directory" do + result = Dir.empty? __FILE__ + result.should be_false + end - it "raises ENOENT for nonexistent directories" do - lambda { Dir.empty? tmp("nonexistent") }.should raise_error(Errno::ENOENT) - end + it "raises ENOENT for nonexistent directories" do + lambda { Dir.empty? tmp("nonexistent") }.should raise_error(Errno::ENOENT) end end diff --git a/spec/ruby/core/enumerable/chunk_spec.rb b/spec/ruby/core/enumerable/chunk_spec.rb index 34fa651b33..3f8a691da5 100644 --- a/spec/ruby/core/enumerable/chunk_spec.rb +++ b/spec/ruby/core/enumerable/chunk_spec.rb @@ -6,21 +6,11 @@ describe "Enumerable#chunk" do ScratchPad.record [] end - ruby_version_is ""..."2.4" do - it "raises an ArgumentError if called without a block" do - lambda do - EnumerableSpecs::Numerous.new.chunk - end.should raise_error(ArgumentError) - end - end - - ruby_version_is "2.4" do - it "returns an Enumerator if called without a block" do - chunk = EnumerableSpecs::Numerous.new(1, 2, 3, 1, 2).chunk - chunk.should be_an_instance_of(Enumerator) - result = chunk.with_index {|elt, i| elt - i }.to_a - result.should == [[1, [1, 2, 3]], [-2, [1, 2]]] - end + it "returns an Enumerator if called without a block" do + chunk = EnumerableSpecs::Numerous.new(1, 2, 3, 1, 2).chunk + chunk.should be_an_instance_of(Enumerator) + result = chunk.with_index {|elt, i| elt - i }.to_a + result.should == [[1, [1, 2, 3]], [-2, [1, 2]]] end it "returns an Enumerator if given a block" do diff --git a/spec/ruby/core/enumerable/sum_spec.rb b/spec/ruby/core/enumerable/sum_spec.rb index 77b66bc1ec..c9d7017b45 100644 --- a/spec/ruby/core/enumerable/sum_spec.rb +++ b/spec/ruby/core/enumerable/sum_spec.rb @@ -1,30 +1,28 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is '2.4' do - describe 'Enumerable#sum' do - before :each do - @enum = Object.new.to_enum - class << @enum - def each - yield 0 - yield(-1) - yield 2 - yield 2/3r - end +describe 'Enumerable#sum' do + before :each do + @enum = Object.new.to_enum + class << @enum + def each + yield 0 + yield(-1) + yield 2 + yield 2/3r end end + end - it 'returns amount of the elements with taking an argument as the initial value' do - @enum.sum(10).should == 35/3r - end + it 'returns amount of the elements with taking an argument as the initial value' do + @enum.sum(10).should == 35/3r + end - it 'gives 0 as a default argument' do - @enum.sum.should == 5/3r - end + it 'gives 0 as a default argument' do + @enum.sum.should == 5/3r + end - it 'takes a block to transform the elements' do - @enum.sum { |element| element * 2 }.should == 10/3r - end + it 'takes a block to transform the elements' do + @enum.sum { |element| element * 2 }.should == 10/3r end end diff --git a/spec/ruby/core/enumerable/uniq_spec.rb b/spec/ruby/core/enumerable/uniq_spec.rb index eb1e70c208..c286882e92 100644 --- a/spec/ruby/core/enumerable/uniq_spec.rb +++ b/spec/ruby/core/enumerable/uniq_spec.rb @@ -1,94 +1,90 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is '2.4' do - describe 'Enumerable#uniq' do - it 'returns an array that contains only unique elements' do - [0, 1, 2, 3].to_enum.uniq { |n| n.even? }.should == [0, 1] - end +describe 'Enumerable#uniq' do + it 'returns an array that contains only unique elements' do + [0, 1, 2, 3].to_enum.uniq { |n| n.even? }.should == [0, 1] + end - it "uses eql? semantics" do - [1.0, 1].to_enum.uniq.should == [1.0, 1] - end + it "uses eql? semantics" do + [1.0, 1].to_enum.uniq.should == [1.0, 1] + end - it "compares elements first with hash" do - x = mock('0') - x.should_receive(:hash).at_least(1).and_return(0) - y = mock('0') - y.should_receive(:hash).at_least(1).and_return(0) + it "compares elements first with hash" do + x = mock('0') + x.should_receive(:hash).at_least(1).and_return(0) + y = mock('0') + y.should_receive(:hash).at_least(1).and_return(0) - [x, y].to_enum.uniq.should == [x, y] - end - - it "does not compare elements with different hash codes via eql?" do - x = mock('0') - x.should_not_receive(:eql?) - y = mock('1') - y.should_not_receive(:eql?) + [x, y].to_enum.uniq.should == [x, y] + end - x.should_receive(:hash).at_least(1).and_return(0) - y.should_receive(:hash).at_least(1).and_return(1) + it "does not compare elements with different hash codes via eql?" do + x = mock('0') + x.should_not_receive(:eql?) + y = mock('1') + y.should_not_receive(:eql?) - [x, y].to_enum.uniq.should == [x, y] - end + x.should_receive(:hash).at_least(1).and_return(0) + y.should_receive(:hash).at_least(1).and_return(1) - it "compares elements with matching hash codes with #eql?" do - a = Array.new(2) do - obj = mock('0') - obj.should_receive(:hash).at_least(1).and_return(0) - - def obj.eql?(o) - # It's undefined whether the impl does a[0].eql?(a[1]) or - # a[1].eql?(a[0]) so we taint both. - taint - o.taint - false - end + [x, y].to_enum.uniq.should == [x, y] + end - obj + it "compares elements with matching hash codes with #eql?" do + a = Array.new(2) do + obj = mock('0') + obj.should_receive(:hash).at_least(1).and_return(0) + + def obj.eql?(o) + # It's undefined whether the impl does a[0].eql?(a[1]) or + # a[1].eql?(a[0]) so we taint both. + taint + o.taint + false end - a.uniq.should == a - a[0].tainted?.should == true - a[1].tainted?.should == true + obj + end - a = Array.new(2) do - obj = mock('0') - obj.should_receive(:hash).at_least(1).and_return(0) + a.uniq.should == a + a[0].tainted?.should == true + a[1].tainted?.should == true - def obj.eql?(o) - # It's undefined whether the impl does a[0].eql?(a[1]) or - # a[1].eql?(a[0]) so we taint both. - taint - o.taint - true - end + a = Array.new(2) do + obj = mock('0') + obj.should_receive(:hash).at_least(1).and_return(0) - obj + def obj.eql?(o) + # It's undefined whether the impl does a[0].eql?(a[1]) or + # a[1].eql?(a[0]) so we taint both. + taint + o.taint + true end - a.to_enum.uniq.size.should == 1 - a[0].tainted?.should == true - a[1].tainted?.should == true + obj end - context 'when yielded with multiple arguments' do - before :each do - @enum = Object.new.to_enum - class << @enum - def each - yield 0, 'foo' - yield 1, 'FOO' - yield 2, 'bar' - end - end - end + a.to_enum.uniq.size.should == 1 + a[0].tainted?.should == true + a[1].tainted?.should == true + end - ruby_bug '#13669', ''...'2.5' do - it 'returns all yield arguments as an array' do - @enum.uniq { |_, label| label.downcase }.should == [[0, 'foo'], [2, 'bar']] + context 'when yielded with multiple arguments' do + before :each do + @enum = Object.new.to_enum + class << @enum + def each + yield 0, 'foo' + yield 1, 'FOO' + yield 2, 'bar' end end end + + it 'returns all yield arguments as an array' do + @enum.uniq { |_, label| label.downcase }.should == [[0, 'foo'], [2, 'bar']] + end end end diff --git a/spec/ruby/core/enumerator/lazy/chunk_spec.rb b/spec/ruby/core/enumerator/lazy/chunk_spec.rb index 3f60c6ea3f..87d2b0c206 100644 --- a/spec/ruby/core/enumerator/lazy/chunk_spec.rb +++ b/spec/ruby/core/enumerator/lazy/chunk_spec.rb @@ -25,22 +25,12 @@ describe "Enumerator::Lazy#chunk" do Enumerator::Lazy.new(Object.new, 100) {}.chunk { |v| v }.size.should == nil end - ruby_version_is ""..."2.4" do - it "raises an ArgumentError if called without a block" do - lambda do - @yieldsmixed.chunk - end.should raise_error(ArgumentError) - end - end + it "returns an Enumerator if called without a block" do + chunk = @yieldsmixed.chunk + chunk.should be_an_instance_of(Enumerator::Lazy) - ruby_version_is "2.4" do - it "returns an Enumerator if called without a block" do - chunk = @yieldsmixed.chunk - chunk.should be_an_instance_of(Enumerator::Lazy) - - res = chunk.each { |v| true }.force - res.should == [[true, EnumeratorLazySpecs::YieldsMixed.gathered_yields]] - end + res = chunk.each { |v| true }.force + res.should == [[true, EnumeratorLazySpecs::YieldsMixed.gathered_yields]] end describe "when the returned lazy enumerator is evaluated by Enumerable#first" do diff --git a/spec/ruby/core/enumerator/lazy/lazy_spec.rb b/spec/ruby/core/enumerator/lazy/lazy_spec.rb index 21fbfc27ab..cde9b31066 100644 --- a/spec/ruby/core/enumerator/lazy/lazy_spec.rb +++ b/spec/ruby/core/enumerator/lazy/lazy_spec.rb @@ -14,9 +14,7 @@ describe "Enumerator::Lazy" do :select, :slice_after, :slice_before, :slice_when, :take, :take_while, :to_enum, :zip ] - ruby_version_is "2.4" do - lazy_methods += [:chunk_while, :uniq] - end + lazy_methods += [:chunk_while, :uniq] Enumerator::Lazy.instance_methods(false).should include(*lazy_methods) end diff --git a/spec/ruby/core/enumerator/lazy/select_spec.rb b/spec/ruby/core/enumerator/lazy/select_spec.rb index c4143c5251..3773d8f0a8 100644 --- a/spec/ruby/core/enumerator/lazy/select_spec.rb +++ b/spec/ruby/core/enumerator/lazy/select_spec.rb @@ -5,4 +5,43 @@ require_relative 'shared/select' describe "Enumerator::Lazy#select" do it_behaves_like :enumerator_lazy_select, :select + + it "doesn't pre-evaluate the next element" do + eval_count = 0 + enum = %w[Text1 Text2 Text3].lazy.select do + eval_count += 1 + true + end + + eval_count.should == 0 + enum.next + eval_count.should == 1 + end + + it "doesn't over-evaluate when peeked" do + eval_count = 0 + enum = %w[Text1 Text2 Text3].lazy.select do + eval_count += 1 + true + end + + eval_count.should == 0 + enum.peek + enum.peek + eval_count.should == 1 + end + + it "doesn't re-evaluate after peek" do + eval_count = 0 + enum = %w[Text1 Text2 Text3].lazy.select do + eval_count += 1 + true + end + + eval_count.should == 0 + enum.peek + eval_count.should == 1 + enum.next + eval_count.should == 1 + end end diff --git a/spec/ruby/core/enumerator/lazy/uniq_spec.rb b/spec/ruby/core/enumerator/lazy/uniq_spec.rb index d337d063d6..ce67ace5ab 100644 --- a/spec/ruby/core/enumerator/lazy/uniq_spec.rb +++ b/spec/ruby/core/enumerator/lazy/uniq_spec.rb @@ -1,82 +1,74 @@ require_relative '../../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is '2.4' do - describe 'Enumerator::Lazy#uniq' do - context 'without block' do - before :each do - @lazy = [0, 1, 0, 1].to_enum.lazy.uniq - end - - it 'returns a lazy enumerator' do - @lazy.should be_an_instance_of(Enumerator::Lazy) - @lazy.force.should == [0, 1] - end +describe 'Enumerator::Lazy#uniq' do + context 'without block' do + before :each do + @lazy = [0, 1, 0, 1].to_enum.lazy.uniq + end - ruby_bug "#14495", "2.4"..."2.5.2" do - it 'return same value after rewind' do - @lazy.force.should == [0, 1] - @lazy.force.should == [0, 1] - end - end + it 'returns a lazy enumerator' do + @lazy.should be_an_instance_of(Enumerator::Lazy) + @lazy.force.should == [0, 1] + end - it 'sets the size to nil' do - @lazy.size.should == nil - end + it 'return same value after rewind' do + @lazy.force.should == [0, 1] + @lazy.force.should == [0, 1] end - context 'when yielded with an argument' do - before :each do - @lazy = [0, 1, 2, 3].to_enum.lazy.uniq(&:even?) - end + it 'sets the size to nil' do + @lazy.size.should == nil + end + end - it 'returns a lazy enumerator' do - @lazy.should be_an_instance_of(Enumerator::Lazy) - @lazy.force.should == [0, 1] - end + context 'when yielded with an argument' do + before :each do + @lazy = [0, 1, 2, 3].to_enum.lazy.uniq(&:even?) + end - ruby_bug "#14495", "2.4"..."2.5.2" do - it 'return same value after rewind' do - @lazy.force.should == [0, 1] - @lazy.force.should == [0, 1] - end - end + it 'returns a lazy enumerator' do + @lazy.should be_an_instance_of(Enumerator::Lazy) + @lazy.force.should == [0, 1] + end - it 'sets the size to nil' do - @lazy.size.should == nil - end + it 'return same value after rewind' do + @lazy.force.should == [0, 1] + @lazy.force.should == [0, 1] end - context 'when yielded with multiple arguments' do - before :each do - enum = Object.new.to_enum - class << enum - def each - yield 0, 'foo' - yield 1, 'FOO' - yield 2, 'bar' - end - end - @lazy = enum.lazy - end + it 'sets the size to nil' do + @lazy.size.should == nil + end + end - ruby_bug "#14495", "2.4"..."2.5.2" do - it 'return same value after rewind' do - enum = @lazy.uniq { |_, label| label.downcase } - enum.force.should == [[0, 'foo'], [2, 'bar']] - enum.force.should == [[0, 'foo'], [2, 'bar']] + context 'when yielded with multiple arguments' do + before :each do + enum = Object.new.to_enum + class << enum + def each + yield 0, 'foo' + yield 1, 'FOO' + yield 2, 'bar' end end + @lazy = enum.lazy + end - it 'returns all yield arguments as an array' do - @lazy.uniq { |_, label| label.downcase }.force.should == [[0, 'foo'], [2, 'bar']] - end + it 'return same value after rewind' do + enum = @lazy.uniq { |_, label| label.downcase } + enum.force.should == [[0, 'foo'], [2, 'bar']] + enum.force.should == [[0, 'foo'], [2, 'bar']] end - it "works with an infinite enumerable" do - s = 0..Float::INFINITY - s.lazy.uniq.first(100).should == - s.first(100).uniq + it 'returns all yield arguments as an array' do + @lazy.uniq { |_, label| label.downcase }.force.should == [[0, 'foo'], [2, 'bar']] end end + + it "works with an infinite enumerable" do + s = 0..Float::INFINITY + s.lazy.uniq.first(100).should == + s.first(100).uniq + end end diff --git a/spec/ruby/core/env/fetch_spec.rb b/spec/ruby/core/env/fetch_spec.rb index ea9995a3b0..c8a11430ab 100644 --- a/spec/ruby/core/env/fetch_spec.rb +++ b/spec/ruby/core/env/fetch_spec.rb @@ -14,6 +14,12 @@ describe "ENV.fetch" do context "when the key is not found" do it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, ENV + + it "formats the object with #inspect in the KeyError message" do + -> { + ENV.fetch('foo') + }.should raise_error(KeyError, 'key not found: "foo"') + end end it "provides the given default parameter" do diff --git a/spec/ruby/core/false/dup_spec.rb b/spec/ruby/core/false/dup_spec.rb index 24360a9fc1..1a569a2f4f 100644 --- a/spec/ruby/core/false/dup_spec.rb +++ b/spec/ruby/core/false/dup_spec.rb @@ -1,9 +1,7 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "FalseClass#dup" do - it "returns self" do - false.dup.should equal(false) - end +describe "FalseClass#dup" do + it "returns self" do + false.dup.should equal(false) end end diff --git a/spec/ruby/core/fiber/resume_spec.rb b/spec/ruby/core/fiber/resume_spec.rb index 2f15a834d4..d05e62c455 100644 --- a/spec/ruby/core/fiber/resume_spec.rb +++ b/spec/ruby/core/fiber/resume_spec.rb @@ -42,7 +42,7 @@ with_feature :fiber do f.resume # When we execute the second #resume call, the ensure block DOES exit, - # the ensure clause runs. This is Ruby behavior as of 2.3.1. + # the ensure clause runs. f.resume exit 0 diff --git a/spec/ruby/core/file/empty_spec.rb b/spec/ruby/core/file/empty_spec.rb index a904f140e6..77f132303e 100644 --- a/spec/ruby/core/file/empty_spec.rb +++ b/spec/ruby/core/file/empty_spec.rb @@ -2,14 +2,12 @@ require_relative '../../spec_helper' require_relative '../../shared/file/zero' describe "File.empty?" do - ruby_version_is "2.4" do - it_behaves_like :file_zero, :empty?, File - it_behaves_like :file_zero_missing, :empty?, File + it_behaves_like :file_zero, :empty?, File + it_behaves_like :file_zero_missing, :empty?, File - platform_is :solaris do - it "returns false for /dev/null" do - File.empty?('/dev/null').should == true - end + platform_is :solaris do + it "returns false for /dev/null" do + File.empty?('/dev/null').should == true end end end diff --git a/spec/ruby/core/file/expand_path_spec.rb b/spec/ruby/core/file/expand_path_spec.rb index 6e24e62075..b03bb3a2ca 100644 --- a/spec/ruby/core/file/expand_path_spec.rb +++ b/spec/ruby/core/file/expand_path_spec.rb @@ -222,16 +222,14 @@ platform_is_not :windows do ENV["HOME"] = @home end - ruby_version_is ''...'2.4' do - it "raises an ArgumentError when passed '~' if HOME is nil" do - ENV.delete "HOME" - lambda { File.expand_path("~") }.should raise_error(ArgumentError) - end + it "uses the user database when passed '~' if HOME is nil" do + ENV.delete "HOME" + File.directory?(File.expand_path("~")).should == true + end - it "raises an ArgumentError when passed '~/' if HOME is nil" do - ENV.delete "HOME" - lambda { File.expand_path("~/") }.should raise_error(ArgumentError) - end + it "uses the user database when passed '~/' if HOME is nil" do + ENV.delete "HOME" + File.directory?(File.expand_path("~/")).should == true end it "raises an ArgumentError when passed '~' if HOME == ''" do diff --git a/spec/ruby/core/file/mtime_spec.rb b/spec/ruby/core/file/mtime_spec.rb index c5d854bb08..833f759eaa 100644 --- a/spec/ruby/core/file/mtime_spec.rb +++ b/spec/ruby/core/file/mtime_spec.rb @@ -12,7 +12,7 @@ describe "File.mtime" do it "returns the modification Time of the file" do File.mtime(@filename).should be_kind_of(Time) - File.mtime(@filename).should be_close(@mtime, 60.0) + File.mtime(@filename).should be_close(@mtime, TIME_TOLERANCE) end guard -> { platform_is :linux or (platform_is :windows and ruby_version_is '2.5') } do diff --git a/spec/ruby/core/file/stat/dev_major_spec.rb b/spec/ruby/core/file/stat/dev_major_spec.rb index 845c883a42..4966d609e2 100644 --- a/spec/ruby/core/file/stat/dev_major_spec.rb +++ b/spec/ruby/core/file/stat/dev_major_spec.rb @@ -9,11 +9,9 @@ describe "File::Stat#dev_major" do rm_r @name end - ruby_version_is "2.4" do - platform_is_not :windows do - it "returns the major part of File::Stat#dev" do - File.stat(@name).dev_major.should be_kind_of(Integer) - end + platform_is_not :windows do + it "returns the major part of File::Stat#dev" do + File.stat(@name).dev_major.should be_kind_of(Integer) end end diff --git a/spec/ruby/core/file/stat/dev_minor_spec.rb b/spec/ruby/core/file/stat/dev_minor_spec.rb index ddfb6a7b6a..ea79c12b99 100644 --- a/spec/ruby/core/file/stat/dev_minor_spec.rb +++ b/spec/ruby/core/file/stat/dev_minor_spec.rb @@ -9,11 +9,9 @@ describe "File::Stat#dev_minor" do rm_r @name end - ruby_version_is "2.4" do - platform_is_not :windows do - it "returns the minor part of File::Stat#dev" do - File.stat(@name).dev_minor.should be_kind_of(Integer) - end + platform_is_not :windows do + it "returns the minor part of File::Stat#dev" do + File.stat(@name).dev_minor.should be_kind_of(Integer) end end diff --git a/spec/ruby/core/file/stat/rdev_major_spec.rb b/spec/ruby/core/file/stat/rdev_major_spec.rb index 3d7f6ef759..f8a8d1b107 100644 --- a/spec/ruby/core/file/stat/rdev_major_spec.rb +++ b/spec/ruby/core/file/stat/rdev_major_spec.rb @@ -17,11 +17,9 @@ describe "File::Stat#rdev_major" do end end - ruby_version_is "2.4" do - platform_is_not :windows do - it "returns the major part of File::Stat#rdev" do - File.stat(@name).rdev_major.should be_kind_of(Integer) - end + platform_is_not :windows do + it "returns the major part of File::Stat#rdev" do + File.stat(@name).rdev_major.should be_kind_of(Integer) end end diff --git a/spec/ruby/core/file/stat/rdev_minor_spec.rb b/spec/ruby/core/file/stat/rdev_minor_spec.rb index e25c61ca86..dc30c1f56c 100644 --- a/spec/ruby/core/file/stat/rdev_minor_spec.rb +++ b/spec/ruby/core/file/stat/rdev_minor_spec.rb @@ -17,11 +17,9 @@ describe "File::Stat#rdev_minor" do end end - ruby_version_is "2.4" do - platform_is_not :windows do - it "returns the minor part of File::Stat#rdev" do - File.stat(@name).rdev_minor.should be_kind_of(Integer) - end + platform_is_not :windows do + it "returns the minor part of File::Stat#rdev" do + File.stat(@name).rdev_minor.should be_kind_of(Integer) end end diff --git a/spec/ruby/core/file/utime_spec.rb b/spec/ruby/core/file/utime_spec.rb index 64af82ef19..03adc76efe 100644 --- a/spec/ruby/core/file/utime_spec.rb +++ b/spec/ruby/core/file/utime_spec.rb @@ -27,10 +27,10 @@ describe "File.utime" do File.atime(@file2).should be_close(@atime, 0.0001) File.mtime(@file2).should be_close(@mtime, 0.0001) else - File.atime(@file1).to_i.should be_close(@atime.to_i, 2) - File.mtime(@file1).to_i.should be_close(@mtime.to_i, 2) - File.atime(@file2).to_i.should be_close(@atime.to_i, 2) - File.mtime(@file2).to_i.should be_close(@mtime.to_i, 2) + File.atime(@file1).to_i.should be_close(@atime.to_i, TIME_TOLERANCE) + File.mtime(@file1).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE) + File.atime(@file2).to_i.should be_close(@atime.to_i, TIME_TOLERANCE) + File.mtime(@file2).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE) end end @@ -43,10 +43,10 @@ describe "File.utime" do File.atime(@file2).should be_close(tn, 0.050) File.mtime(@file2).should be_close(tn, 0.050) else - File.atime(@file1).to_i.should be_close(Time.now.to_i, 2) - File.mtime(@file1).to_i.should be_close(Time.now.to_i, 2) - File.atime(@file2).to_i.should be_close(Time.now.to_i, 2) - File.mtime(@file2).to_i.should be_close(Time.now.to_i, 2) + File.atime(@file1).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE) + File.mtime(@file1).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE) + File.atime(@file2).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE) + File.mtime(@file2).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE) end end @@ -63,10 +63,10 @@ describe "File.utime" do File.mtime(@file2).should be_close(@mtime, 0.0001) else File.utime(@atime.to_i, @mtime.to_i, @file1, @file2) - File.atime(@file1).to_i.should be_close(@atime.to_i, 2) - File.mtime(@file1).to_i.should be_close(@mtime.to_i, 2) - File.atime(@file2).to_i.should be_close(@atime.to_i, 2) - File.mtime(@file2).to_i.should be_close(@mtime.to_i, 2) + File.atime(@file1).to_i.should be_close(@atime.to_i, TIME_TOLERANCE) + File.mtime(@file1).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE) + File.atime(@file2).to_i.should be_close(@atime.to_i, TIME_TOLERANCE) + File.mtime(@file2).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE) end end diff --git a/spec/ruby/core/float/ceil_spec.rb b/spec/ruby/core/float/ceil_spec.rb index 8a4f72c70e..7fc18d304c 100644 --- a/spec/ruby/core/float/ceil_spec.rb +++ b/spec/ruby/core/float/ceil_spec.rb @@ -11,13 +11,11 @@ describe "Float#ceil" do +9223372036854775808.1.ceil.should eql(+9223372036854775808) end - ruby_version_is "2.4" do - it "returns the smallest number greater than or equal to self with an optionally given precision" do - 2.1679.ceil(0).should eql(3) - 214.94.ceil(-1).should eql(220) - 7.0.ceil(1).should eql(7.0) - -1.234.ceil(2).should eql(-1.23) - 5.123812.ceil(4).should eql(5.1239) - end + it "returns the smallest number greater than or equal to self with an optionally given precision" do + 2.1679.ceil(0).should eql(3) + 214.94.ceil(-1).should eql(220) + 7.0.ceil(1).should eql(7.0) + -1.234.ceil(2).should eql(-1.23) + 5.123812.ceil(4).should eql(5.1239) end end diff --git a/spec/ruby/core/float/dup_spec.rb b/spec/ruby/core/float/dup_spec.rb index 8df7260652..294da8e2bc 100644 --- a/spec/ruby/core/float/dup_spec.rb +++ b/spec/ruby/core/float/dup_spec.rb @@ -1,10 +1,8 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "Float#dup" do - it "returns self" do - float = 2.4 - float.dup.should equal(float) - end +describe "Float#dup" do + it "returns self" do + float = 2.4 + float.dup.should equal(float) end end diff --git a/spec/ruby/core/float/floor_spec.rb b/spec/ruby/core/float/floor_spec.rb index f20eccae73..046216d36d 100644 --- a/spec/ruby/core/float/floor_spec.rb +++ b/spec/ruby/core/float/floor_spec.rb @@ -11,13 +11,11 @@ describe "Float#floor" do +9223372036854775808.1.floor.should eql(+9223372036854775808) end - ruby_version_is "2.4" do - it "returns the largest number less than or equal to self with an optionally given precision" do - 2.1679.floor(0).should eql(2) - 214.94.floor(-1).should eql(210) - 7.0.floor(1).should eql(7.0) - -1.234.floor(2).should eql(-1.24) - 5.123812.floor(4).should eql(5.1238) - end + it "returns the largest number less than or equal to self with an optionally given precision" do + 2.1679.floor(0).should eql(2) + 214.94.floor(-1).should eql(210) + 7.0.floor(1).should eql(7.0) + -1.234.floor(2).should eql(-1.24) + 5.123812.floor(4).should eql(5.1238) end end diff --git a/spec/ruby/core/float/round_spec.rb b/spec/ruby/core/float/round_spec.rb index a21173e139..d5ca532c5a 100644 --- a/spec/ruby/core/float/round_spec.rb +++ b/spec/ruby/core/float/round_spec.rb @@ -83,17 +83,35 @@ describe "Float#round" do -2.4e200.round(-200).should eql( -2 * 10 ** 200 ) end - ruby_version_is "2.4" do - it "returns different rounded values depending on the half option" do - 2.5.round(half: :up).should eql(3) - 2.5.round(half: :down).should eql(2) - 2.5.round(half: :even).should eql(2) - 3.5.round(half: :up).should eql(4) - 3.5.round(half: :down).should eql(3) - 3.5.round(half: :even).should eql(4) - (-2.5).round(half: :up).should eql(-3) - (-2.5).round(half: :down).should eql(-2) - (-2.5).round(half: :even).should eql(-2) - end + it "returns different rounded values depending on the half option" do + 2.5.round(half: nil).should eql(3) + 2.5.round(half: :up).should eql(3) + 2.5.round(half: :down).should eql(2) + 2.5.round(half: :even).should eql(2) + 3.5.round(half: nil).should eql(4) + 3.5.round(half: :up).should eql(4) + 3.5.round(half: :down).should eql(3) + 3.5.round(half: :even).should eql(4) + (-2.5).round(half: nil).should eql(-3) + (-2.5).round(half: :up).should eql(-3) + (-2.5).round(half: :down).should eql(-2) + (-2.5).round(half: :even).should eql(-2) + end + + it "rounds self to an optionally given precision with a half option" do + 5.55.round(1, half: nil).should eql(5.6) + 5.55.round(1, half: :up).should eql(5.6) + 5.55.round(1, half: :down).should eql(5.5) + 5.55.round(1, half: :even).should eql(5.6) + end + + it "raises FloatDomainError for exceptional values with a half option" do + lambda { (+infinity_value).round(half: :up) }.should raise_error(FloatDomainError) + lambda { (-infinity_value).round(half: :down) }.should raise_error(FloatDomainError) + lambda { nan_value.round(half: :even) }.should raise_error(FloatDomainError) + end + + it "raise for a non-existent round mode" do + lambda { 14.2.round(half: :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode: nonsense") end end diff --git a/spec/ruby/core/float/truncate_spec.rb b/spec/ruby/core/float/truncate_spec.rb index 5c219da960..2c80145f9f 100644 --- a/spec/ruby/core/float/truncate_spec.rb +++ b/spec/ruby/core/float/truncate_spec.rb @@ -4,13 +4,11 @@ require_relative 'shared/to_i' describe "Float#truncate" do it_behaves_like :float_to_i, :truncate - ruby_version_is "2.4" do - it "returns self truncated to an optionally given precision" do - 2.1679.truncate(0).should eql(2) - 7.1.truncate(1).should eql(7.1) - 214.94.truncate(-1).should eql(210) - -1.234.truncate(2).should eql(-1.23) - 5.123812.truncate(4).should eql(5.1238) - end + it "returns self truncated to an optionally given precision" do + 2.1679.truncate(0).should eql(2) + 7.1.truncate(1).should eql(7.1) + 214.94.truncate(-1).should eql(210) + -1.234.truncate(2).should eql(-1.23) + 5.123812.truncate(4).should eql(5.1238) end end diff --git a/spec/ruby/core/hash/compact_spec.rb b/spec/ruby/core/hash/compact_spec.rb index b75621b4d4..ec9d4b5d79 100644 --- a/spec/ruby/core/hash/compact_spec.rb +++ b/spec/ruby/core/hash/compact_spec.rb @@ -1,61 +1,59 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is "2.4" do - describe "Hash#compact" do - before :each do - @hash = { truthy: true, false: false, nil: nil, nil => true } - @initial_pairs = @hash.dup - @compact = { truthy: true, false: false, nil => true } - end +describe "Hash#compact" do + before :each do + @hash = { truthy: true, false: false, nil: nil, nil => true } + @initial_pairs = @hash.dup + @compact = { truthy: true, false: false, nil => true } + end - it "returns new object that rejects pair has nil value" do - ret = @hash.compact - ret.should_not equal(@hash) - ret.should == @compact - end + it "returns new object that rejects pair has nil value" do + ret = @hash.compact + ret.should_not equal(@hash) + ret.should == @compact + end - it "keeps own pairs" do - @hash.compact - @hash.should == @initial_pairs - end + it "keeps own pairs" do + @hash.compact + @hash.should == @initial_pairs end +end - describe "Hash#compact!" do - before :each do - @hash = { truthy: true, false: false, nil: nil, nil => true } - @initial_pairs = @hash.dup - @compact = { truthy: true, false: false, nil => true } - end +describe "Hash#compact!" do + before :each do + @hash = { truthy: true, false: false, nil: nil, nil => true } + @initial_pairs = @hash.dup + @compact = { truthy: true, false: false, nil => true } + end - it "returns self" do - @hash.compact!.should equal(@hash) - end + it "returns self" do + @hash.compact!.should equal(@hash) + end - it "rejects own pair has nil value" do + it "rejects own pair has nil value" do + @hash.compact! + @hash.should == @compact + end + + context "when each pair does not have nil value" do + before :each do @hash.compact! - @hash.should == @compact end - context "when each pair does not have nil value" do - before :each do - @hash.compact! - end - - it "returns nil" do - @hash.compact!.should be_nil - end + it "returns nil" do + @hash.compact!.should be_nil end + end - describe "on frozen instance" do - before :each do - @hash.freeze - end + describe "on frozen instance" do + before :each do + @hash.freeze + end - it "keeps pairs and raises a #{frozen_error_class}" do - ->{ @hash.compact! }.should raise_error(frozen_error_class) - @hash.should == @initial_pairs - end + it "keeps pairs and raises a #{frozen_error_class}" do + ->{ @hash.compact! }.should raise_error(frozen_error_class) + @hash.should == @initial_pairs end end end diff --git a/spec/ruby/core/hash/compare_by_identity_spec.rb b/spec/ruby/core/hash/compare_by_identity_spec.rb index e463c311be..33db59124e 100644 --- a/spec/ruby/core/hash/compare_by_identity_spec.rb +++ b/spec/ruby/core/hash/compare_by_identity_spec.rb @@ -108,13 +108,11 @@ describe "Hash#compare_by_identity" do @idh.keys.first.should equal foo end - ruby_bug "#12855", ""..."2.4.1" do - it "gives different identity for string literals" do - @idh['foo'] = 1 - @idh['foo'] = 2 - @idh.values.should == [1, 2] - @idh.size.should == 2 - end + it "gives different identity for string literals" do + @idh['foo'] = 1 + @idh['foo'] = 2 + @idh.values.should == [1, 2] + @idh.size.should == 2 end end diff --git a/spec/ruby/core/hash/fetch_spec.rb b/spec/ruby/core/hash/fetch_spec.rb index 2fee5d0164..197832e311 100644 --- a/spec/ruby/core/hash/fetch_spec.rb +++ b/spec/ruby/core/hash/fetch_spec.rb @@ -8,6 +8,12 @@ describe "Hash#fetch" do it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, {} it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, Hash.new { 5 } it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, Hash.new(5) + + it "formats the object with #inspect in the KeyError message" do + -> { + {}.fetch('foo') + }.should raise_error(KeyError, 'key not found: "foo"') + end end it "returns the value for key" do diff --git a/spec/ruby/core/hash/merge_spec.rb b/spec/ruby/core/hash/merge_spec.rb index 5ea70610be..e90beae87a 100644 --- a/spec/ruby/core/hash/merge_spec.rb +++ b/spec/ruby/core/hash/merge_spec.rb @@ -69,9 +69,12 @@ describe "Hash#merge" do result.should == { a: 1, b: 2, c: 3, d: 4 } end - it "accepts zero arguments and returns self" do + it "accepts zero arguments and returns a copy of self" do hash = { a: 1 } - hash.merge.should eql(hash) + merged = hash.merge + + merged.should eql(hash) + merged.should_not equal(hash) end end end diff --git a/spec/ruby/core/hash/shared/each.rb b/spec/ruby/core/hash/shared/each.rb index 1d89cfdd39..d1f2e5f672 100644 --- a/spec/ruby/core/hash/shared/each.rb +++ b/spec/ruby/core/hash/shared/each.rb @@ -21,7 +21,7 @@ describe :hash_each, shared: true do ary.sort.should == ["a", "b", "c"] end - it "yields 2 values and not an Array of 2 elements" do + it "yields 2 values and not an Array of 2 elements when given a callable of arity 2" do obj = Object.new def obj.foo(key, value) ScratchPad << key << value diff --git a/spec/ruby/core/hash/transform_values_spec.rb b/spec/ruby/core/hash/transform_values_spec.rb index 80e875097a..8b53b7a522 100644 --- a/spec/ruby/core/hash/transform_values_spec.rb +++ b/spec/ruby/core/hash/transform_values_spec.rb @@ -1,98 +1,96 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Hash#transform_values" do - before :each do - @hash = { a: 1, b: 2, c: 3 } - end +describe "Hash#transform_values" do + before :each do + @hash = { a: 1, b: 2, c: 3 } + end - it "returns new hash" do - ret = @hash.transform_values(&:succ) - ret.should_not equal(@hash) - ret.should be_an_instance_of(Hash) - end + it "returns new hash" do + ret = @hash.transform_values(&:succ) + ret.should_not equal(@hash) + ret.should be_an_instance_of(Hash) + end - it "sets the result as transformed values with the given block" do - @hash.transform_values(&:succ).should == { a: 2, b: 3, c: 4 } - end + it "sets the result as transformed values with the given block" do + @hash.transform_values(&:succ).should == { a: 2, b: 3, c: 4 } + end - it "makes both hashes to share keys" do - key = [1, 2, 3] - new_hash = { key => 1 }.transform_values(&:succ) - new_hash[key].should == 2 - new_hash.keys[0].should equal(key) - end + it "makes both hashes to share keys" do + key = [1, 2, 3] + new_hash = { key => 1 }.transform_values(&:succ) + new_hash[key].should == 2 + new_hash.keys[0].should equal(key) + end - context "when no block is given" do - it "returns a sized Enumerator" do - enumerator = @hash.transform_values - enumerator.should be_an_instance_of(Enumerator) - enumerator.size.should == @hash.size - enumerator.each(&:succ).should == { a: 2, b: 3, c: 4 } - end + context "when no block is given" do + it "returns a sized Enumerator" do + enumerator = @hash.transform_values + enumerator.should be_an_instance_of(Enumerator) + enumerator.size.should == @hash.size + enumerator.each(&:succ).should == { a: 2, b: 3, c: 4 } end + end - it "returns a Hash instance, even on subclasses" do - klass = Class.new(Hash) - h = klass.new - h[:foo] = 42 - r = h.transform_values{|v| 2 * v} - r[:foo].should == 84 - r.class.should == Hash - end + it "returns a Hash instance, even on subclasses" do + klass = Class.new(Hash) + h = klass.new + h[:foo] = 42 + r = h.transform_values{|v| 2 * v} + r[:foo].should == 84 + r.class.should == Hash end +end - describe "Hash#transform_values!" do - before :each do - @hash = { a: 1, b: 2, c: 3 } - @initial_pairs = @hash.dup - end +describe "Hash#transform_values!" do + before :each do + @hash = { a: 1, b: 2, c: 3 } + @initial_pairs = @hash.dup + end - it "returns self" do - @hash.transform_values!(&:succ).should equal(@hash) + it "returns self" do + @hash.transform_values!(&:succ).should equal(@hash) + end + + it "updates self as transformed values with the given block" do + @hash.transform_values!(&:succ) + @hash.should == { a: 2, b: 3, c: 4 } + end + + it "partially modifies the contents if we broke from the block" do + @hash.transform_values! do |v| + break if v == 3 + 100 + v end + @hash.should == { a: 101, b: 102, c: 3} + end - it "updates self as transformed values with the given block" do - @hash.transform_values!(&:succ) + context "when no block is given" do + it "returns a sized Enumerator" do + enumerator = @hash.transform_values! + enumerator.should be_an_instance_of(Enumerator) + enumerator.size.should == @hash.size + enumerator.each(&:succ) @hash.should == { a: 2, b: 3, c: 4 } end + end - it "partially modifies the contents if we broke from the block" do - @hash.transform_values! do |v| - break if v == 3 - 100 + v - end - @hash.should == { a: 101, b: 102, c: 3} + describe "on frozen instance" do + before :each do + @hash.freeze end - context "when no block is given" do - it "returns a sized Enumerator" do - enumerator = @hash.transform_values! - enumerator.should be_an_instance_of(Enumerator) - enumerator.size.should == @hash.size - enumerator.each(&:succ) - @hash.should == { a: 2, b: 3, c: 4 } - end + it "raises a #{frozen_error_class} on an empty hash" do + ->{ {}.freeze.transform_values!(&:succ) }.should raise_error(frozen_error_class) end - describe "on frozen instance" do - before :each do - @hash.freeze - end - - it "raises a #{frozen_error_class} on an empty hash" do - ->{ {}.freeze.transform_values!(&:succ) }.should raise_error(frozen_error_class) - end - - it "keeps pairs and raises a #{frozen_error_class}" do - ->{ @hash.transform_values!(&:succ) }.should raise_error(frozen_error_class) - @hash.should == @initial_pairs - end + it "keeps pairs and raises a #{frozen_error_class}" do + ->{ @hash.transform_values!(&:succ) }.should raise_error(frozen_error_class) + @hash.should == @initial_pairs + end - context "when no block is given" do - it "does not raise an exception" do - @hash.transform_values!.should be_an_instance_of(Enumerator) - end + context "when no block is given" do + it "does not raise an exception" do + @hash.transform_values!.should be_an_instance_of(Enumerator) end end end diff --git a/spec/ruby/core/integer/ceil_spec.rb b/spec/ruby/core/integer/ceil_spec.rb index 9e1311bc6d..13bdaf838d 100644 --- a/spec/ruby/core/integer/ceil_spec.rb +++ b/spec/ruby/core/integer/ceil_spec.rb @@ -6,16 +6,14 @@ describe "Integer#ceil" do it_behaves_like :integer_to_i, :ceil it_behaves_like :integer_rounding_positive_precision, :ceil - ruby_version_is "2.4" do - context "precision argument specified as part of the ceil method is negative" do - it "returns the smallest integer greater than self with at least precision.abs trailing zeros" do - 18.ceil(-1).should eql(20) - 18.ceil(-2).should eql(100) - 18.ceil(-3).should eql(1000) - -1832.ceil(-1).should eql(-1830) - -1832.ceil(-2).should eql(-1800) - -1832.ceil(-3).should eql(-1000) - end + context "precision argument specified as part of the ceil method is negative" do + it "returns the smallest integer greater than self with at least precision.abs trailing zeros" do + 18.ceil(-1).should eql(20) + 18.ceil(-2).should eql(100) + 18.ceil(-3).should eql(1000) + -1832.ceil(-1).should eql(-1830) + -1832.ceil(-2).should eql(-1800) + -1832.ceil(-3).should eql(-1000) end end end diff --git a/spec/ruby/core/integer/coerce_spec.rb b/spec/ruby/core/integer/coerce_spec.rb index 1bc30fe9ce..8db15bbaed 100644 --- a/spec/ruby/core/integer/coerce_spec.rb +++ b/spec/ruby/core/integer/coerce_spec.rb @@ -68,38 +68,24 @@ describe "Integer#coerce" do lambda { a.coerce(:test) }.should raise_error(TypeError) end - ruby_version_is ""..."2.4" do - it "raises a TypeError when passed a String" do - a = bignum_value - lambda { a.coerce("123") }.should raise_error(TypeError) - end - - it "raises a TypeError when passed a Float" do - a = bignum_value - lambda { a.coerce(12.3) }.should raise_error(TypeError) - end + it "coerces both values to Floats and returns [other, self] when passed a Float" do + a = bignum_value + a.coerce(1.2).should == [1.2, a.to_f] end - ruby_version_is "2.4" do - it "coerces both values to Floats and returns [other, self] when passed a Float" do - a = bignum_value - a.coerce(1.2).should == [1.2, a.to_f] - end - - it "coerces both values to Floats and returns [other, self] when passed a String" do - a = bignum_value - a.coerce("123").should == [123.0, a.to_f] - end + it "coerces both values to Floats and returns [other, self] when passed a String" do + a = bignum_value + a.coerce("123").should == [123.0, a.to_f] + end - it "calls #to_f to coerce other to a Float" do - b = mock("bignum value") - b.should_receive(:to_f).and_return(1.2) + it "calls #to_f to coerce other to a Float" do + b = mock("bignum value") + b.should_receive(:to_f).and_return(1.2) - a = bignum_value - ary = a.coerce(b) + a = bignum_value + ary = a.coerce(b) - ary.should == [1.2, a.to_f] - end + ary.should == [1.2, a.to_f] end end end diff --git a/spec/ruby/core/integer/digits_spec.rb b/spec/ruby/core/integer/digits_spec.rb index a60650246b..85afb6f50f 100644 --- a/spec/ruby/core/integer/digits_spec.rb +++ b/spec/ruby/core/integer/digits_spec.rb @@ -1,34 +1,32 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Integer#digits" do - it "returns an array of place values in base-10 by default" do - 12345.digits.should == [5,4,3,2,1] - end +describe "Integer#digits" do + it "returns an array of place values in base-10 by default" do + 12345.digits.should == [5,4,3,2,1] + end - it "returns digits by place value of a given radix" do - 12345.digits(7).should == [4,6,6,0,5] - end + it "returns digits by place value of a given radix" do + 12345.digits(7).should == [4,6,6,0,5] + end - it "converts the radix with #to_int" do - 12345.digits(mock_int(2)).should == [1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1] - end + it "converts the radix with #to_int" do + 12345.digits(mock_int(2)).should == [1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1] + end - it "returns [0] when called on 0, regardless of base" do - 0.digits.should == [0] - 0.digits(7).should == [0] - end + it "returns [0] when called on 0, regardless of base" do + 0.digits.should == [0] + 0.digits(7).should == [0] + end - it "raises ArgumentError when calling with a radix less than 2" do - lambda { 12345.digits(1) }.should raise_error(ArgumentError) - end + it "raises ArgumentError when calling with a radix less than 2" do + lambda { 12345.digits(1) }.should raise_error(ArgumentError) + end - it "raises ArgumentError when calling with a negative radix" do - lambda { 12345.digits(-2) }.should raise_error(ArgumentError) - end + it "raises ArgumentError when calling with a negative radix" do + lambda { 12345.digits(-2) }.should raise_error(ArgumentError) + end - it "raises Math::DomainError when calling digits on a negative number" do - lambda { -12345.digits(7) }.should raise_error(Math::DomainError) - end + it "raises Math::DomainError when calling digits on a negative number" do + lambda { -12345.digits(7) }.should raise_error(Math::DomainError) end end diff --git a/spec/ruby/core/integer/dup_spec.rb b/spec/ruby/core/integer/dup_spec.rb index 214367f0b4..7f4d512465 100644 --- a/spec/ruby/core/integer/dup_spec.rb +++ b/spec/ruby/core/integer/dup_spec.rb @@ -1,15 +1,13 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "Integer#dup" do - it "returns self for small integers" do - integer = 1_000 - integer.dup.should equal(integer) - end +describe "Integer#dup" do + it "returns self for small integers" do + integer = 1_000 + integer.dup.should equal(integer) + end - it "returns self for large integers" do - integer = 4_611_686_018_427_387_905 - integer.dup.should equal(integer) - end + it "returns self for large integers" do + integer = 4_611_686_018_427_387_905 + integer.dup.should equal(integer) end end diff --git a/spec/ruby/core/integer/floor_spec.rb b/spec/ruby/core/integer/floor_spec.rb index 58439c98c1..aaa816fdc5 100644 --- a/spec/ruby/core/integer/floor_spec.rb +++ b/spec/ruby/core/integer/floor_spec.rb @@ -6,16 +6,14 @@ describe "Integer#floor" do it_behaves_like :integer_to_i, :floor it_behaves_like :integer_rounding_positive_precision, :floor - ruby_version_is "2.4" do - context "precision argument specified as part of the floor method is negative" do - it "returns the largest integer less than self with at least precision.abs trailing zeros" do - 1832.floor(-1).should eql(1830) - 1832.floor(-2).should eql(1800) - 1832.floor(-3).should eql(1000) - -1832.floor(-1).should eql(-1840) - -1832.floor(-2).should eql(-1900) - -1832.floor(-3).should eql(-2000) - end + context "precision argument specified as part of the floor method is negative" do + it "returns the largest integer less than self with at least precision.abs trailing zeros" do + 1832.floor(-1).should eql(1830) + 1832.floor(-2).should eql(1800) + 1832.floor(-3).should eql(1000) + -1832.floor(-1).should eql(-1840) + -1832.floor(-2).should eql(-1900) + -1832.floor(-3).should eql(-2000) end end end diff --git a/spec/ruby/core/integer/integer_spec.rb b/spec/ruby/core/integer/integer_spec.rb index 6db2d50346..f8067cda06 100644 --- a/spec/ruby/core/integer/integer_spec.rb +++ b/spec/ruby/core/integer/integer_spec.rb @@ -5,11 +5,9 @@ describe "Integer" do Integer.include?(Comparable).should == true end - ruby_version_is "2.4" do - it "is the class of both small and large integers" do - 42.class.should equal(Integer) - bignum_value.class.should equal(Integer) - end + it "is the class of both small and large integers" do + 42.class.should equal(Integer) + bignum_value.class.should equal(Integer) end end diff --git a/spec/ruby/core/integer/pow_spec.rb b/spec/ruby/core/integer/pow_spec.rb index fb0ba996bc..ed14c40a27 100644 --- a/spec/ruby/core/integer/pow_spec.rb +++ b/spec/ruby/core/integer/pow_spec.rb @@ -16,13 +16,11 @@ ruby_version_is "2.5" do 2.pow(8, 15).should == 1 end - ruby_bug '#13669', '2.5'...'2.5.1' do - it "works well with bignums" do - 2.pow(61, 5843009213693951).should eql 3697379018277258 - 2.pow(62, 5843009213693952).should eql 1551748822859776 - 2.pow(63, 5843009213693953).should eql 3103497645717974 - 2.pow(64, 5843009213693954).should eql 363986077738838 - end + it "works well with bignums" do + 2.pow(61, 5843009213693951).should eql 3697379018277258 + 2.pow(62, 5843009213693952).should eql 1551748822859776 + 2.pow(63, 5843009213693953).should eql 3103497645717974 + 2.pow(64, 5843009213693954).should eql 363986077738838 end it "handles sign like #divmod does" do diff --git a/spec/ruby/core/integer/round_spec.rb b/spec/ruby/core/integer/round_spec.rb index aa6345fda5..622a55280e 100644 --- a/spec/ruby/core/integer/round_spec.rb +++ b/spec/ruby/core/integer/round_spec.rb @@ -63,18 +63,16 @@ describe "Integer#round" do lambda { 42.round(obj) }.should raise_error(TypeError) end - ruby_version_is "2.4" do - it "returns different rounded values depending on the half option" do - 25.round(-1, half: :up).should eql(30) - 25.round(-1, half: :down).should eql(20) - 25.round(-1, half: :even).should eql(20) - 35.round(-1, half: :up).should eql(40) - 35.round(-1, half: :down).should eql(30) - 35.round(-1, half: :even).should eql(40) - (-25).round(-1, half: :up).should eql(-30) - (-25).round(-1, half: :down).should eql(-20) - (-25).round(-1, half: :even).should eql(-20) - end + it "returns different rounded values depending on the half option" do + 25.round(-1, half: :up).should eql(30) + 25.round(-1, half: :down).should eql(20) + 25.round(-1, half: :even).should eql(20) + 35.round(-1, half: :up).should eql(40) + 35.round(-1, half: :down).should eql(30) + 35.round(-1, half: :even).should eql(40) + (-25).round(-1, half: :up).should eql(-30) + (-25).round(-1, half: :down).should eql(-20) + (-25).round(-1, half: :even).should eql(-20) end ruby_version_is "2.4"..."2.5" do diff --git a/spec/ruby/core/integer/shared/integer_rounding.rb b/spec/ruby/core/integer/shared/integer_rounding.rb index ecbda1bb4a..3fb6e830ef 100644 --- a/spec/ruby/core/integer/shared/integer_rounding.rb +++ b/spec/ruby/core/integer/shared/integer_rounding.rb @@ -5,11 +5,9 @@ describe :integer_rounding_positive_precision, shared: true do end end - ruby_version_is "2.4" do - it "returns self if passed a precision of zero" do - [2, -4, 10**70, -10**100].each do |v| - v.send(@method, 0).should eql(v) - end + it "returns self if passed a precision of zero" do + [2, -4, 10**70, -10**100].each do |v| + v.send(@method, 0).should eql(v) end end diff --git a/spec/ruby/core/integer/truncate_spec.rb b/spec/ruby/core/integer/truncate_spec.rb index 761a3dbd31..db16e74be4 100644 --- a/spec/ruby/core/integer/truncate_spec.rb +++ b/spec/ruby/core/integer/truncate_spec.rb @@ -6,16 +6,14 @@ describe "Integer#truncate" do it_behaves_like :integer_to_i, :truncate it_behaves_like :integer_rounding_positive_precision, :truncate - ruby_version_is "2.4" do - context "precision argument specified as part of the truncate method is negative" do - it "returns an integer with at least precision.abs trailing zeros" do - 1832.truncate(-1).should eql(1830) - 1832.truncate(-2).should eql(1800) - 1832.truncate(-3).should eql(1000) - -1832.truncate(-1).should eql(-1830) - -1832.truncate(-2).should eql(-1800) - -1832.truncate(-3).should eql(-1000) - end + context "precision argument specified as part of the truncate method is negative" do + it "returns an integer with at least precision.abs trailing zeros" do + 1832.truncate(-1).should eql(1830) + 1832.truncate(-2).should eql(1800) + 1832.truncate(-3).should eql(1000) + -1832.truncate(-1).should eql(-1830) + -1832.truncate(-2).should eql(-1800) + -1832.truncate(-3).should eql(-1000) end end end diff --git a/spec/ruby/core/io/gets_spec.rb b/spec/ruby/core/io/gets_spec.rb index b22b226beb..525c7547cd 100644 --- a/spec/ruby/core/io/gets_spec.rb +++ b/spec/ruby/core/io/gets_spec.rb @@ -139,11 +139,9 @@ describe "IO#gets" do end end - ruby_version_is "2.4" do - describe "when passed chomp" do - it "returns the first line without a trailing newline character" do - @io.gets(chomp: true).should == IOSpecs.lines_without_newline_characters[0] - end + describe "when passed chomp" do + it "returns the first line without a trailing newline character" do + @io.gets(chomp: true).should == IOSpecs.lines_without_newline_characters[0] end end end diff --git a/spec/ruby/core/io/readline_spec.rb b/spec/ruby/core/io/readline_spec.rb index f82ba36a1d..3eae6bfa47 100644 --- a/spec/ruby/core/io/readline_spec.rb +++ b/spec/ruby/core/io/readline_spec.rb @@ -43,11 +43,9 @@ describe "IO#readline" do end end - ruby_version_is "2.4" do - describe "when passed chomp" do - it "returns the first line without a trailing newline character" do - @io.readline(chomp: true).should == IOSpecs.lines_without_newline_characters[0] - end + describe "when passed chomp" do + it "returns the first line without a trailing newline character" do + @io.readline(chomp: true).should == IOSpecs.lines_without_newline_characters[0] end end end diff --git a/spec/ruby/core/io/shared/each.rb b/spec/ruby/core/io/shared/each.rb index ac01a49df1..da562e03b1 100644 --- a/spec/ruby/core/io/shared/each.rb +++ b/spec/ruby/core/io/shared/each.rb @@ -156,12 +156,10 @@ describe :io_each, shared: true do end end - ruby_version_is "2.4" do - describe "when passed chomp" do - it "yields each line without trailing newline characters to the passed block" do - @io.send(@method, chomp: true) { |s| ScratchPad << s } - ScratchPad.recorded.should == IOSpecs.lines_without_newline_characters - end + describe "when passed chomp" do + it "yields each line without trailing newline characters to the passed block" do + @io.send(@method, chomp: true) { |s| ScratchPad << s } + ScratchPad.recorded.should == IOSpecs.lines_without_newline_characters end end end diff --git a/spec/ruby/core/io/shared/readlines.rb b/spec/ruby/core/io/shared/readlines.rb index f545d8876a..08d41e0a4c 100644 --- a/spec/ruby/core/io/shared/readlines.rb +++ b/spec/ruby/core/io/shared/readlines.rb @@ -18,11 +18,9 @@ describe :io_readlines, shared: true do (result ? result : ScratchPad.recorded).should == IOSpecs.lines_empty_separator end - ruby_version_is "2.4" do - it "yields a sequence of lines without trailing newline characters when chomp is passed" do - result = IO.send(@method, @name, chomp: true, &@object) - (result ? result : ScratchPad.recorded).should == IOSpecs.lines_without_newline_characters - end + it "yields a sequence of lines without trailing newline characters when chomp is passed" do + result = IO.send(@method, @name, chomp: true, &@object) + (result ? result : ScratchPad.recorded).should == IOSpecs.lines_without_newline_characters end end diff --git a/spec/ruby/core/kernel/Complex_spec.rb b/spec/ruby/core/kernel/Complex_spec.rb index e5435a56e6..cb90718759 100644 --- a/spec/ruby/core/kernel/Complex_spec.rb +++ b/spec/ruby/core/kernel/Complex_spec.rb @@ -175,13 +175,11 @@ describe "Kernel.Complex()" do end end - ruby_bug "#15525", "2.6"..."2.6.1" do - describe "and nil arguments" do - it "swallows an error" do - Complex(nil, exception: false).should == nil - Complex(0, nil, exception: false).should == nil - Complex(nil, 0, exception: false).should == nil - end + describe "and nil arguments" do + it "swallows an error" do + Complex(nil, exception: false).should == nil + Complex(0, nil, exception: false).should == nil + Complex(nil, 0, exception: false).should == nil end end end diff --git a/spec/ruby/core/kernel/Integer_spec.rb b/spec/ruby/core/kernel/Integer_spec.rb index 72e33fc737..b7e05e701b 100644 --- a/spec/ruby/core/kernel/Integer_spec.rb +++ b/spec/ruby/core/kernel/Integer_spec.rb @@ -125,17 +125,15 @@ describe :kernel_integer, shared: true do end end - ruby_bug "#15525", "2.6"..."2.6.1" do - describe "and passed NaN" do - it "swallows an error" do - Integer(nan_value, exception: false).should == nil - end + describe "and passed NaN" do + it "swallows an error" do + Integer(nan_value, exception: false).should == nil end + end - describe "and passed Infinity" do - it "swallows an error" do - Integer(infinity_value, exception: false).should == nil - end + describe "and passed Infinity" do + it "swallows an error" do + Integer(infinity_value, exception: false).should == nil end end diff --git a/spec/ruby/core/kernel/clone_spec.rb b/spec/ruby/core/kernel/clone_spec.rb index ed426c2927..eb8739d571 100644 --- a/spec/ruby/core/kernel/clone_spec.rb +++ b/spec/ruby/core/kernel/clone_spec.rb @@ -37,14 +37,12 @@ describe "Kernel#clone" do o3.frozen?.should == true end - ruby_version_is '2.4' do - it 'takes an option to copy freeze state or not' do - @obj.clone(freeze: true).frozen?.should == false - @obj.clone(freeze: false).frozen?.should == false - @obj.freeze - @obj.clone(freeze: true).frozen?.should == true - @obj.clone(freeze: false).frozen?.should == false - end + it 'takes an option to copy freeze state or not' do + @obj.clone(freeze: true).frozen?.should == false + @obj.clone(freeze: false).frozen?.should == false + @obj.freeze + @obj.clone(freeze: true).frozen?.should == true + @obj.clone(freeze: false).frozen?.should == false end it "copies instance variables" do diff --git a/spec/ruby/core/kernel/shared/dup_clone.rb b/spec/ruby/core/kernel/shared/dup_clone.rb index 116989958b..37890f2981 100644 --- a/spec/ruby/core/kernel/shared/dup_clone.rb +++ b/spec/ruby/core/kernel/shared/dup_clone.rb @@ -79,48 +79,24 @@ describe :kernel_dup_clone, shared: true do o3.untrusted?.should == true end - ruby_version_is ''...'2.4' do - it "raises a TypeError for NilClass" do - lambda { nil.send(@method) }.should raise_error(TypeError) - end - - it "raises a TypeError for TrueClass" do - lambda { true.send(@method) }.should raise_error(TypeError) - end - - it "raises a TypeError for FalseClass" do - lambda { false.send(@method) }.should raise_error(TypeError) - end - - it "raises a TypeError for Fixnum" do - lambda { 1.send(@method) }.should raise_error(TypeError) - end - - it "raises a TypeError for Symbol" do - lambda { :my_symbol.send(@method) }.should raise_error(TypeError) - end + it "returns nil for NilClass" do + nil.send(@method).should == nil end - ruby_version_is '2.4' do - it "returns nil for NilClass" do - nil.send(@method).should == nil - end - - it "returns true for TrueClass" do - true.send(@method).should == true - end + it "returns true for TrueClass" do + true.send(@method).should == true + end - it "returns false for FalseClass" do - false.send(@method).should == false - end + it "returns false for FalseClass" do + false.send(@method).should == false + end - it "returns the same Integer for Integer" do - 1.send(@method).should == 1 - end + it "returns the same Integer for Integer" do + 1.send(@method).should == 1 + end - it "returns the same Symbol for Symbol" do - :my_symbol.send(@method).should == :my_symbol - end + it "returns the same Symbol for Symbol" do + :my_symbol.send(@method).should == :my_symbol end ruby_version_is ''...'2.5' do diff --git a/spec/ruby/core/kernel/shared/require.rb b/spec/ruby/core/kernel/shared/require.rb index b502476bc3..56377684fb 100644 --- a/spec/ruby/core/kernel/shared/require.rb +++ b/spec/ruby/core/kernel/shared/require.rb @@ -553,6 +553,15 @@ describe :kernel_require, shared: true do required = ruby_exe(code, options: '--disable-gems') required.should == "false\n" * provided.size end + + it "unicode_normalize is part of core and not $LOADED_FEATURES" do + features = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems') + features.lines.each { |feature| + feature.should_not include("unicode_normalize") + } + + -> { @object.require("unicode_normalize") }.should raise_error(LoadError) + end end end diff --git a/spec/ruby/core/kernel/warn_spec.rb b/spec/ruby/core/kernel/warn_spec.rb index 0b461ec25a..7e0a57fa9a 100644 --- a/spec/ruby/core/kernel/warn_spec.rb +++ b/spec/ruby/core/kernel/warn_spec.rb @@ -101,11 +101,9 @@ describe "Kernel#warn" do -> { w.f4("foo", 3) }.should output(nil, %r|core/kernel/fixtures/classes.rb:#{w.f3_call_lineno}: warning: foo|) end - ruby_bug "#14846", "2.5"..."2.6" do - it "does not prepend caller information if line number is too big" do - w = KernelSpecs::WarnInNestedCall.new - -> { w.f4("foo", 100) }.should output(nil, "warning: foo\n") - end + it "does not prepend caller information if line number is too big" do + w = KernelSpecs::WarnInNestedCall.new + -> { w.f4("foo", 100) }.should output(nil, "warning: foo\n") end it "prepends even if a message is empty or nil" do @@ -127,10 +125,8 @@ describe "Kernel#warn" do -> { warn "", uplevel: -100 }.should raise_error(ArgumentError) end - ruby_bug "#14846", "2.5"..."2.6" do - it "raises ArgumentError if passed -1" do - -> { warn "", uplevel: -1 }.should raise_error(ArgumentError) - end + it "raises ArgumentError if passed -1" do + -> { warn "", uplevel: -1 }.should raise_error(ArgumentError) end it "raises TypeError if passed not Integer" do diff --git a/spec/ruby/core/matchdata/named_captures_spec.rb b/spec/ruby/core/matchdata/named_captures_spec.rb index 0b0771355f..9b1e324a24 100644 --- a/spec/ruby/core/matchdata/named_captures_spec.rb +++ b/spec/ruby/core/matchdata/named_captures_spec.rb @@ -1,17 +1,15 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe 'MatchData#named_captures' do - it 'returns a Hash that has captured name and the matched string pairs' do - /(?<a>.)(?<b>.)?/.match('0').named_captures.should == { 'a' => '0', 'b' => nil } - end +describe 'MatchData#named_captures' do + it 'returns a Hash that has captured name and the matched string pairs' do + /(?<a>.)(?<b>.)?/.match('0').named_captures.should == { 'a' => '0', 'b' => nil } + end - it 'prefers later captures' do - /\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)\z/.match('0123').named_captures.should == { 'a' => '3', 'b' => '2' } - end + it 'prefers later captures' do + /\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)\z/.match('0123').named_captures.should == { 'a' => '3', 'b' => '2' } + end - it 'returns the latest matched capture, even if a later one that does not match exists' do - /\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)?\z/.match('012').named_captures.should == { 'a' => '0', 'b' => '2' } - end + it 'returns the latest matched capture, even if a later one that does not match exists' do + /\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)?\z/.match('012').named_captures.should == { 'a' => '0', 'b' => '2' } end end diff --git a/spec/ruby/core/matchdata/values_at_spec.rb b/spec/ruby/core/matchdata/values_at_spec.rb index af844904f6..8f7fdf557c 100644 --- a/spec/ruby/core/matchdata/values_at_spec.rb +++ b/spec/ruby/core/matchdata/values_at_spec.rb @@ -11,13 +11,11 @@ describe "MatchData#values_at" do end end - ruby_version_is '2.4' do - it 'slices captures with the given names' do - /(?<a>.)(?<b>.)(?<c>.)/.match('012').values_at(:c, :a).should == ['2', '0'] - end + it 'slices captures with the given names' do + /(?<a>.)(?<b>.)(?<c>.)/.match('012').values_at(:c, :a).should == ['2', '0'] + end - it 'takes names and indices' do - /\A(?<a>.)(?<b>.)\z/.match('01').values_at(0, 1, 2, :a, :b).should == ['01', '0', '1', '0', '1'] - end + it 'takes names and indices' do + /\A(?<a>.)(?<b>.)\z/.match('01').values_at(0, 1, 2, :a, :b).should == ['01', '0', '1', '0', '1'] end end diff --git a/spec/ruby/core/math/lgamma_spec.rb b/spec/ruby/core/math/lgamma_spec.rb index 7104f2aa21..a20d0a4f2f 100644 --- a/spec/ruby/core/math/lgamma_spec.rb +++ b/spec/ruby/core/math/lgamma_spec.rb @@ -11,10 +11,8 @@ describe "Math.lgamma" do end end - ruby_version_is "2.4" do - it "returns [Infinity, -1] when passed -0.0" do - Math.lgamma(-0.0).should == [infinity_value, -1] - end + it "returns [Infinity, -1] when passed -0.0" do + Math.lgamma(-0.0).should == [infinity_value, -1] end it "returns [log(sqrt(PI)), 1] when passed 0.5" do diff --git a/spec/ruby/core/method/parameters_spec.rb b/spec/ruby/core/method/parameters_spec.rb index 750abe13d0..1de3901040 100644 --- a/spec/ruby/core/method/parameters_spec.rb +++ b/spec/ruby/core/method/parameters_spec.rb @@ -243,17 +243,19 @@ describe "Method#parameters" do end it "returns [[:rest]] for core methods with variable-length argument lists" do - m = "foo" - - # match takes rest args - m.method(:match).parameters.should == [[:rest]] + # delete! takes rest args + "foo".method(:delete!).parameters.should == [[:rest]] + end - # [] takes 1 to 3 args - m.method(:[]).parameters.should == [[:rest]] + it "returns [[:rest]] or [[:opt]] for core methods with optional arguments" do + # pop takes 1 optional argument + [ + [[:rest]], + [[:opt]] + ].should include([].method(:pop).parameters) end it "returns [[:req]] for each parameter for core methods with fixed-length argument lists" do - m = "foo" - m.method(:+).parameters.should == [[:req]] + "foo".method(:+).parameters.should == [[:req]] end end diff --git a/spec/ruby/core/module/include_spec.rb b/spec/ruby/core/module/include_spec.rb index 2a31afa59a..ece86bfe00 100644 --- a/spec/ruby/core/module/include_spec.rb +++ b/spec/ruby/core/module/include_spec.rb @@ -165,24 +165,12 @@ describe "Module#include" do }.should raise_error(ArgumentError) end - ruby_version_is ''...'2.4' do - it "accepts no-arguments" do - lambda { - Module.new do - include - end - }.should_not raise_error - end - end - - ruby_version_is '2.4' do - it "doesn't accept no-arguments" do - lambda { - Module.new do - include - end - }.should raise_error(ArgumentError) - end + it "doesn't accept no-arguments" do + lambda { + Module.new do + include + end + }.should raise_error(ArgumentError) end it "returns the class it's included into" do diff --git a/spec/ruby/core/module/prepend_spec.rb b/spec/ruby/core/module/prepend_spec.rb index ca80eb360f..b186381640 100644 --- a/spec/ruby/core/module/prepend_spec.rb +++ b/spec/ruby/core/module/prepend_spec.rb @@ -231,24 +231,12 @@ describe "Module#prepend" do }.should raise_error(ArgumentError) end - ruby_version_is ''...'2.4' do - it "accepts no-arguments" do - lambda { - Module.new do - prepend - end - }.should_not raise_error - end - end - - ruby_version_is '2.4' do - it "doesn't accept no-arguments" do - lambda { - Module.new do - prepend - end - }.should raise_error(ArgumentError) - end + it "doesn't accept no-arguments" do + lambda { + Module.new do + prepend + end + }.should raise_error(ArgumentError) end it "returns the class it's included into" do diff --git a/spec/ruby/core/module/private_spec.rb b/spec/ruby/core/module/private_spec.rb index d476c6f54e..5d85c34855 100644 --- a/spec/ruby/core/module/private_spec.rb +++ b/spec/ruby/core/module/private_spec.rb @@ -52,44 +52,42 @@ describe "Module#private" do end.should raise_error(NameError) end - ruby_bug "#14604", ""..."2.5.1" do - it "only makes the method private in the class it is called on" do - base = Class.new do - def wrapped - 1 - end + it "only makes the method private in the class it is called on" do + base = Class.new do + def wrapped + 1 end + end - klass = Class.new(base) do - def wrapped - super + 1 - end - private :wrapped + klass = Class.new(base) do + def wrapped + super + 1 end - - base.new.wrapped.should == 1 - lambda do - klass.new.wrapped - end.should raise_error(NameError) + private :wrapped end - it "continues to allow a prepended module method to call super" do - wrapper = Module.new do - def wrapped - super + 1 - end + base.new.wrapped.should == 1 + lambda do + klass.new.wrapped + end.should raise_error(NameError) + end + + it "continues to allow a prepended module method to call super" do + wrapper = Module.new do + def wrapped + super + 1 end + end - klass = Class.new do - prepend wrapper + klass = Class.new do + prepend wrapper - def wrapped - 1 - end - private :wrapped + def wrapped + 1 end - - klass.new.wrapped.should == 2 + private :wrapped end + + klass.new.wrapped.should == 2 end end diff --git a/spec/ruby/core/module/refine_spec.rb b/spec/ruby/core/module/refine_spec.rb index 4f34062343..7a1b2fc5fc 100644 --- a/spec/ruby/core/module/refine_spec.rb +++ b/spec/ruby/core/module/refine_spec.rb @@ -74,29 +74,17 @@ describe "Module#refine" do end.should raise_error(TypeError) end - ruby_version_is "" ... "2.4" do - it "raises TypeError if passed a module" do - lambda do - Module.new do - refine(Enumerable) {} - end - end.should raise_error(TypeError) - end - end - - ruby_version_is "2.4" do - it "accepts a module as argument" do - inner_self = nil - Module.new do - refine(Enumerable) do - def blah - end - inner_self = self + it "accepts a module as argument" do + inner_self = nil + Module.new do + refine(Enumerable) do + def blah end + inner_self = self end - - inner_self.public_instance_methods.should include(:blah) end + + inner_self.public_instance_methods.should include(:blah) end it "raises ArgumentError if not given a block" do @@ -319,108 +307,54 @@ describe "Module#refine" do end context "for methods accessed indirectly" do - ruby_version_is "" ... "2.4" do - it "is not honored by Kernel#send" do - refinement = Module.new do - refine ModuleSpecs::ClassWithFoo do - def foo; "foo from refinement"; end - end - end - - result = nil - Module.new do - using refinement - result = ModuleSpecs::ClassWithFoo.new.send :foo + it "is honored by Kernel#send" do + refinement = Module.new do + refine ModuleSpecs::ClassWithFoo do + def foo; "foo from refinement"; end end - - result.should == "foo" end - it "is not honored by BasicObject#__send__" do - refinement = Module.new do - refine ModuleSpecs::ClassWithFoo do - def foo; "foo from refinement"; end - end - end - - result = nil - Module.new do - using refinement - result = ModuleSpecs::ClassWithFoo.new.__send__ :foo - end - - result.should == "foo" + result = nil + Module.new do + using refinement + result = ModuleSpecs::ClassWithFoo.new.send :foo end - it "is not honored by Symbol#to_proc" do - refinement = Module.new do - refine Integer do - def to_s - "(#{super})" - end - end - end + result.should == "foo from refinement" + end - result = nil - Module.new do - using refinement - result = [1, 2, 3].map(&:to_s) + it "is honored by BasicObject#__send__" do + refinement = Module.new do + refine ModuleSpecs::ClassWithFoo do + def foo; "foo from refinement"; end end + end - result.should == ["1", "2", "3"] + result = nil + Module.new do + using refinement + result = ModuleSpecs::ClassWithFoo.new.__send__ :foo end + + result.should == "foo from refinement" end - ruby_version_is "2.4" do - it "is honored by Kernel#send" do - refinement = Module.new do - refine ModuleSpecs::ClassWithFoo do - def foo; "foo from refinement"; end + it "is honored by Symbol#to_proc" do + refinement = Module.new do + refine Integer do + def to_s + "(#{super})" end end - - result = nil - Module.new do - using refinement - result = ModuleSpecs::ClassWithFoo.new.send :foo - end - - result.should == "foo from refinement" end - it "is honored by BasicObject#__send__" do - refinement = Module.new do - refine ModuleSpecs::ClassWithFoo do - def foo; "foo from refinement"; end - end - end - - result = nil - Module.new do - using refinement - result = ModuleSpecs::ClassWithFoo.new.__send__ :foo - end - - result.should == "foo from refinement" + result = nil + Module.new do + using refinement + result = [1, 2, 3].map(&:to_s) end - it "is honored by Symbol#to_proc" do - refinement = Module.new do - refine Integer do - def to_s - "(#{super})" - end - end - end - - result = nil - Module.new do - using refinement - result = [1, 2, 3].map(&:to_s) - end - - result.should == ["(1)", "(2)", "(3)"] - end + result.should == ["(1)", "(2)", "(3)"] end ruby_version_is "" ... "2.6" do diff --git a/spec/ruby/core/nil/dup_spec.rb b/spec/ruby/core/nil/dup_spec.rb index 21b2c92220..0324b3f1f4 100644 --- a/spec/ruby/core/nil/dup_spec.rb +++ b/spec/ruby/core/nil/dup_spec.rb @@ -1,9 +1,7 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "NilClass#dup" do - it "returns self" do - nil.dup.should equal(nil) - end +describe "NilClass#dup" do + it "returns self" do + nil.dup.should equal(nil) end end diff --git a/spec/ruby/core/numeric/finite_spec.rb b/spec/ruby/core/numeric/finite_spec.rb index a4df23602b..05b5eebbd6 100644 --- a/spec/ruby/core/numeric/finite_spec.rb +++ b/spec/ruby/core/numeric/finite_spec.rb @@ -1,10 +1,8 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Numeric#finite?" do - it "returns true by default" do - o = mock_numeric("finite") - o.finite?.should be_true - end +describe "Numeric#finite?" do + it "returns true by default" do + o = mock_numeric("finite") + o.finite?.should be_true end end diff --git a/spec/ruby/core/numeric/infinite_spec.rb b/spec/ruby/core/numeric/infinite_spec.rb index 7ed2f6d125..3ea7825c8c 100644 --- a/spec/ruby/core/numeric/infinite_spec.rb +++ b/spec/ruby/core/numeric/infinite_spec.rb @@ -1,10 +1,8 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Numeric#infinite?" do - it "returns nil by default" do - o = mock_numeric("infinite") - o.infinite?.should == nil - end +describe "Numeric#infinite?" do + it "returns nil by default" do + o = mock_numeric("infinite") + o.infinite?.should == nil end end diff --git a/spec/ruby/core/numeric/shared/step.rb b/spec/ruby/core/numeric/shared/step.rb index 066f499dc5..5dcaa4b253 100644 --- a/spec/ruby/core/numeric/shared/step.rb +++ b/spec/ruby/core/numeric/shared/step.rb @@ -224,9 +224,6 @@ describe :numeric_step, :shared => true do describe "when step is a String" do error = nil - ruby_version_is ""..."2.4" do - error = ArgumentError - end ruby_version_is "2.4"..."2.5" do error = TypeError end @@ -305,9 +302,6 @@ describe :numeric_step, :shared => true do describe "size" do describe "when step is a String" do error = nil - ruby_version_is ""..."2.4" do - error = ArgumentError - end ruby_version_is "2.4"..."2.5" do error = TypeError end diff --git a/spec/ruby/core/objectspace/each_object_spec.rb b/spec/ruby/core/objectspace/each_object_spec.rb index c827867fdc..09a582afaf 100644 --- a/spec/ruby/core/objectspace/each_object_spec.rb +++ b/spec/ruby/core/objectspace/each_object_spec.rb @@ -201,7 +201,6 @@ describe "ObjectSpace.each_object" do expected = [ a, b, c, d ] - # singleton classes should be walked only on >= 2.3 expected << c_sclass c_sclass.should be_kind_of(a.singleton_class) diff --git a/spec/ruby/core/proc/element_reference_spec.rb b/spec/ruby/core/proc/element_reference_spec.rb index f60ae1b086..9077e44c34 100644 --- a/spec/ruby/core/proc/element_reference_spec.rb +++ b/spec/ruby/core/proc/element_reference_spec.rb @@ -17,13 +17,11 @@ describe "Proc#call on a Proc created with Kernel#lambda or Kernel#proc" do it_behaves_like :proc_call_on_proc_or_lambda, :call end -ruby_bug "#15118", ""..."2.6" do - describe "Proc#[] with frozen_string_literals" do - it "doesn't duplicate frozen strings" do - ProcArefSpecs.aref.frozen?.should be_false - ProcArefSpecs.aref_freeze.frozen?.should be_true - ProcArefFrozenSpecs.aref.frozen?.should be_true - ProcArefFrozenSpecs.aref_freeze.frozen?.should be_true - end +describe "Proc#[] with frozen_string_literals" do + it "doesn't duplicate frozen strings" do + ProcArefSpecs.aref.frozen?.should be_false + ProcArefSpecs.aref_freeze.frozen?.should be_true + ProcArefFrozenSpecs.aref.frozen?.should be_true + ProcArefFrozenSpecs.aref_freeze.frozen?.should be_true end end diff --git a/spec/ruby/core/process/clock_getres_spec.rb b/spec/ruby/core/process/clock_getres_spec.rb new file mode 100644 index 0000000000..35180bc81b --- /dev/null +++ b/spec/ruby/core/process/clock_getres_spec.rb @@ -0,0 +1,55 @@ +require_relative '../../spec_helper' +require_relative 'fixtures/clocks' + +describe "Process.clock_getres" do + ProcessSpecs.clock_constants.each do |name, value| + it "matches the clock in practice for Process::#{name}" do + times = [] + 10_000.times do + times << Process.clock_gettime(value, :nanosecond) + end + reported = Process.clock_getres(value, :nanosecond) + + # The clock should not be more accurate than reported (times should be + # a multiple of reported precision.) + times.select { |t| t % reported > 0 }.should be_empty + + # We're assuming precision is a multiple of ten - it may or may not + # be an incompatibility if it isn't but we'd like to notice this, + # and the spec following these wouldn't work if it isn't. + reported.should > 0 + (reported == 1 || reported % 10 == 0).should be_true + + # The clock should not be less accurate than reported (times should + # not all be a multiple of the next precision up, assuming precisions + # are multiples of ten.) + times.select { |t| t % (reported * 10) == 0 }.size.should_not == times.size + end + end + + # These are documented + + it "with :GETTIMEOFDAY_BASED_CLOCK_REALTIME reports 1 microsecond" do + Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME, :nanosecond).should == 1_000 + end + + it "with :TIME_BASED_CLOCK_REALTIME reports 1 second" do + Process.clock_getres(:TIME_BASED_CLOCK_REALTIME, :nanosecond).should == 1_000_000_000 + end + + platform_is_not :windows do + it "with :GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID reports 1 microsecond" do + Process.clock_getres(:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID, :nanosecond).should == 1_000 + end + end + + # These are observed + + it "with Process::CLOCK_REALTIME reports at least 1 microsecond" do + Process.clock_getres(Process::CLOCK_REALTIME, :nanosecond).should <= 1_000 + end + + it "with Process::CLOCK_MONOTONIC reports at least 1 microsecond" do + Process.clock_getres(Process::CLOCK_MONOTONIC, :nanosecond).should <= 1_000 + end +end diff --git a/spec/ruby/core/process/clock_gettime_spec.rb b/spec/ruby/core/process/clock_gettime_spec.rb index a7b6bd2b02..4cd13857ea 100644 --- a/spec/ruby/core/process/clock_gettime_spec.rb +++ b/spec/ruby/core/process/clock_gettime_spec.rb @@ -1,18 +1,10 @@ require_relative '../../spec_helper' +require_relative 'fixtures/clocks' describe "Process.clock_gettime" do - platform_is_not :windows, :solaris do - Process.constants.select { |c| - c.to_s.start_with?('CLOCK_') && - # These require CAP_WAKE_ALARM and are not documented in clock_gettime(), - # they return EINVAL if the permission is not granted. - c != :CLOCK_BOOTTIME_ALARM && - c != :CLOCK_REALTIME_ALARM - }.each do |c| - it "can be called with Process::#{c}" do - value = Process.const_get(c) - Process.clock_gettime(value).should be_an_instance_of(Float) - end + ProcessSpecs.clock_constants.each do |name, value| + it "can be called with Process::#{name}" do + Process.clock_gettime(value).should be_an_instance_of(Float) end end @@ -36,7 +28,8 @@ describe "Process.clock_gettime" do t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) t1.should be_an_instance_of(Float) - t2.should be_close(t1, 2.0) # 2.0 is chosen arbitrarily to allow for time skew without admitting failure cases, which would be off by an order of magnitude. + t2.should be_an_instance_of(Float) + t2.should be_close(t1, TIME_TOLERANCE) end it 'uses the default time unit (:float_second) when passed nil' do @@ -44,7 +37,8 @@ describe "Process.clock_gettime" do t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) t1.should be_an_instance_of(Float) - t2.should be_close(t1, 2.0) # 2.0 is chosen arbitrarily to allow for time skew without admitting failure cases, which would be off by an order of magnitude. + t2.should be_an_instance_of(Float) + t2.should be_close(t1, TIME_TOLERANCE) end end end diff --git a/spec/ruby/core/process/fixtures/clocks.rb b/spec/ruby/core/process/fixtures/clocks.rb new file mode 100644 index 0000000000..5f45e8065b --- /dev/null +++ b/spec/ruby/core/process/fixtures/clocks.rb @@ -0,0 +1,24 @@ +module ProcessSpecs + def self.clock_constants + clocks = [] + + platform_is_not :windows, :solaris do + clocks += Process.constants.select { |c| c.to_s.start_with?('CLOCK_') } + + # These require CAP_WAKE_ALARM and are not documented in + # Process#clock_gettime they return EINVAL if the permission + # is not granted. + clocks -= [:CLOCK_BOOTTIME_ALARM, :CLOCK_REALTIME_ALARM] + + # These clocks in practice on Linux do not seem to match + # their reported resolution. + clocks -= [:CLOCK_REALTIME_COARSE, :CLOCK_MONOTONIC_COARSE] + + clocks.map! { |c| + [c, Process.const_get(c)] + } + end + + clocks + end +end diff --git a/spec/ruby/core/process/wait2_spec.rb b/spec/ruby/core/process/wait2_spec.rb index d0163f80af..18bf4be432 100644 --- a/spec/ruby/core/process/wait2_spec.rb +++ b/spec/ruby/core/process/wait2_spec.rb @@ -13,10 +13,8 @@ describe "Process.wait2" do end leaked = Process.waitall $stderr.puts "leaked before wait2 specs: #{leaked}" unless leaked.empty? - with_feature :mjit do - # Ruby-space should not see PIDs used by mjit - leaked.should be_empty - end + # Ruby-space should not see PIDs used by mjit + leaked.should be_empty rescue Errno::ECHILD # No child processes rescue NotImplementedError end diff --git a/spec/ruby/core/process/wait_spec.rb b/spec/ruby/core/process/wait_spec.rb index 099fcdc518..000ff684d4 100644 --- a/spec/ruby/core/process/wait_spec.rb +++ b/spec/ruby/core/process/wait_spec.rb @@ -8,10 +8,8 @@ describe "Process.wait" do begin leaked = Process.waitall puts "leaked before wait specs: #{leaked}" unless leaked.empty? - with_feature :mjit do - # Ruby-space should not see PIDs used by mjit - leaked.should be_empty - end + # Ruby-space should not see PIDs used by mjit + leaked.should be_empty rescue NotImplementedError end end diff --git a/spec/ruby/core/rational/round_spec.rb b/spec/ruby/core/rational/round_spec.rb index deb0caf1b9..36614a552d 100644 --- a/spec/ruby/core/rational/round_spec.rb +++ b/spec/ruby/core/rational/round_spec.rb @@ -1,3 +1,4 @@ +require_relative '../../spec_helper' require_relative '../../shared/rational/round' describe "Rational#round" do diff --git a/spec/ruby/core/regexp/match_spec.rb b/spec/ruby/core/regexp/match_spec.rb index edac0d1d42..45ed4a5932 100644 --- a/spec/ruby/core/regexp/match_spec.rb +++ b/spec/ruby/core/regexp/match_spec.rb @@ -111,32 +111,30 @@ describe "Regexp#match" do end end -ruby_version_is "2.4" do - describe "Regexp#match?" do - before :each do - # Resetting Regexp.last_match - /DONTMATCH/.match '' - end +describe "Regexp#match?" do + before :each do + # Resetting Regexp.last_match + /DONTMATCH/.match '' + end - context "when matches the given value" do - it "returns true but does not set Regexp.last_match" do - /string/i.match?('string').should be_true - Regexp.last_match.should be_nil - end + context "when matches the given value" do + it "returns true but does not set Regexp.last_match" do + /string/i.match?('string').should be_true + Regexp.last_match.should be_nil end + end - it "returns false when does not match the given value" do - /STRING/.match?('string').should be_false - end + it "returns false when does not match the given value" do + /STRING/.match?('string').should be_false + end - it "takes matching position as the 2nd argument" do - /str/i.match?('string', 0).should be_true - /str/i.match?('string', 1).should be_false - end + it "takes matching position as the 2nd argument" do + /str/i.match?('string', 0).should be_true + /str/i.match?('string', 1).should be_false + end - it "returns false when given nil" do - /./.match?(nil).should be_false - end + it "returns false when given nil" do + /./.match?(nil).should be_false end end diff --git a/spec/ruby/core/string/capitalize_spec.rb b/spec/ruby/core/string/capitalize_spec.rb index 10f9ab00a1..c7f4aed20c 100644 --- a/spec/ruby/core/string/capitalize_spec.rb +++ b/spec/ruby/core/string/capitalize_spec.rb @@ -17,77 +17,67 @@ describe "String#capitalize" do "hello".taint.capitalize.tainted?.should == true end - ruby_version_is ''...'2.4' do - it "is locale insensitive (only upcases a-z and only downcases A-Z)" do - "ÄÖÜ".capitalize.should == "ÄÖÜ" - "ärger".capitalize.should == "ärger" - "BÄR".capitalize.should == "BÄr" + describe "full Unicode case mapping" do + it "works for all of Unicode with no option" do + "äöÜ".capitalize.should == "Äöü" end - end - - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "works for all of Unicode with no option" do - "äöÜ".capitalize.should == "Äöü" - end - it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do - "ß".capitalize.should == "Ss" - end + it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do + "ß".capitalize.should == "Ss" + end - it "updates string metadata" do - capitalized = "ßeT".capitalize + it "updates string metadata" do + capitalized = "ßeT".capitalize - capitalized.should == "Sset" - capitalized.size.should == 4 - capitalized.bytesize.should == 4 - capitalized.ascii_only?.should be_true - end + capitalized.should == "Sset" + capitalized.size.should == 4 + capitalized.bytesize.should == 4 + capitalized.ascii_only?.should be_true end + end - describe "ASCII-only case mapping" do - it "does not capitalize non-ASCII characters" do - "ßet".capitalize(:ascii).should == "ßet" - end + describe "ASCII-only case mapping" do + it "does not capitalize non-ASCII characters" do + "ßet".capitalize(:ascii).should == "ßet" end + end - describe "full Unicode case mapping adapted for Turkic languages" do - it "capitalizes ASCII characters according to Turkic semantics" do - "iSa".capitalize(:turkic).should == "İsa" - end - - it "allows Lithuanian as an extra option" do - "iSa".capitalize(:turkic, :lithuanian).should == "İsa" - end - - it "does not allow any other additional option" do - lambda { "iSa".capitalize(:turkic, :ascii) }.should raise_error(ArgumentError) - end + describe "full Unicode case mapping adapted for Turkic languages" do + it "capitalizes ASCII characters according to Turkic semantics" do + "iSa".capitalize(:turkic).should == "İsa" end - describe "full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - "iß".capitalize(:lithuanian).should == "Iß" - end + it "allows Lithuanian as an extra option" do + "iSa".capitalize(:turkic, :lithuanian).should == "İsa" + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - "iß".capitalize(:lithuanian, :turkic).should == "İß" - end + it "does not allow any other additional option" do + lambda { "iSa".capitalize(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "does not allow any other additional option" do - lambda { "iß".capitalize(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + describe "full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + "iß".capitalize(:lithuanian).should == "Iß" end - it "does not allow the :fold option for upcasing" do - lambda { "abc".capitalize(:fold) }.should raise_error(ArgumentError) + it "allows Turkic as an extra option (and applies Turkic semantics)" do + "iß".capitalize(:lithuanian, :turkic).should == "İß" end - it "does not allow invalid options" do - lambda { "abc".capitalize(:invalid_option) }.should raise_error(ArgumentError) + it "does not allow any other additional option" do + lambda { "iß".capitalize(:lithuanian, :ascii) }.should raise_error(ArgumentError) end end + it "does not allow the :fold option for upcasing" do + lambda { "abc".capitalize(:fold) }.should raise_error(ArgumentError) + end + + it "does not allow invalid options" do + lambda { "abc".capitalize(:invalid_option) }.should raise_error(ArgumentError) + end + it "returns subclass instances when called on a subclass" do StringSpecs::MyString.new("hello").capitalize.should be_an_instance_of(StringSpecs::MyString) StringSpecs::MyString.new("Hello").capitalize.should be_an_instance_of(StringSpecs::MyString) @@ -101,84 +91,82 @@ describe "String#capitalize!" do a.should == "Hello" end - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "modifies self in place for all of Unicode with no option" do - a = "äöÜ" - a.capitalize! - a.should == "Äöü" - end + describe "full Unicode case mapping" do + it "modifies self in place for all of Unicode with no option" do + a = "äöÜ" + a.capitalize! + a.should == "Äöü" + end - it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do - a = "ß" - a.capitalize! - a.should == "Ss" - end + it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do + a = "ß" + a.capitalize! + a.should == "Ss" + end - it "updates string metadata" do - capitalized = "ßeT" - capitalized.capitalize! + it "updates string metadata" do + capitalized = "ßeT" + capitalized.capitalize! - capitalized.should == "Sset" - capitalized.size.should == 4 - capitalized.bytesize.should == 4 - capitalized.ascii_only?.should be_true - end + capitalized.should == "Sset" + capitalized.size.should == 4 + capitalized.bytesize.should == 4 + capitalized.ascii_only?.should be_true end + end - describe "modifies self in place for ASCII-only case mapping" do - it "does not capitalize non-ASCII characters" do - a = "ßet" - a.capitalize!(:ascii) - a.should == "ßet" - end + describe "modifies self in place for ASCII-only case mapping" do + it "does not capitalize non-ASCII characters" do + a = "ßet" + a.capitalize!(:ascii) + a.should == "ßet" end + end - describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do - it "capitalizes ASCII characters according to Turkic semantics" do - a = "iSa" - a.capitalize!(:turkic) - a.should == "İsa" - end - - it "allows Lithuanian as an extra option" do - a = "iSa" - a.capitalize!(:turkic, :lithuanian) - a.should == "İsa" - end - - it "does not allow any other additional option" do - lambda { a = "iSa"; a.capitalize!(:turkic, :ascii) }.should raise_error(ArgumentError) - end + describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do + it "capitalizes ASCII characters according to Turkic semantics" do + a = "iSa" + a.capitalize!(:turkic) + a.should == "İsa" end - describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - a = "iß" - a.capitalize!(:lithuanian) - a.should == "Iß" - end + it "allows Lithuanian as an extra option" do + a = "iSa" + a.capitalize!(:turkic, :lithuanian) + a.should == "İsa" + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - a = "iß" - a.capitalize!(:lithuanian, :turkic) - a.should == "İß" - end + it "does not allow any other additional option" do + lambda { a = "iSa"; a.capitalize!(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "does not allow any other additional option" do - lambda { a = "iß"; a.capitalize!(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + a = "iß" + a.capitalize!(:lithuanian) + a.should == "Iß" end - it "does not allow the :fold option for upcasing" do - lambda { a = "abc"; a.capitalize!(:fold) }.should raise_error(ArgumentError) + it "allows Turkic as an extra option (and applies Turkic semantics)" do + a = "iß" + a.capitalize!(:lithuanian, :turkic) + a.should == "İß" end - it "does not allow invalid options" do - lambda { a = "abc"; a.capitalize!(:invalid_option) }.should raise_error(ArgumentError) + it "does not allow any other additional option" do + lambda { a = "iß"; a.capitalize!(:lithuanian, :ascii) }.should raise_error(ArgumentError) end end + it "does not allow the :fold option for upcasing" do + lambda { a = "abc"; a.capitalize!(:fold) }.should raise_error(ArgumentError) + end + + it "does not allow invalid options" do + lambda { a = "abc"; a.capitalize!(:invalid_option) }.should raise_error(ArgumentError) + end + it "returns nil when no changes are made" do a = "Hello" a.capitalize!.should == nil diff --git a/spec/ruby/core/string/casecmp_spec.rb b/spec/ruby/core/string/casecmp_spec.rb index 87be999964..35afcc0152 100644 --- a/spec/ruby/core/string/casecmp_spec.rb +++ b/spec/ruby/core/string/casecmp_spec.rb @@ -101,10 +101,8 @@ describe "String#casecmp independent of case" do @lower_a_tilde.casecmp(@upper_a_tilde).should == 1 end - ruby_version_is "2.4" do - it "does not case fold" do - "ß".casecmp("ss").should == 1 - end + it "does not case fold" do + "ß".casecmp("ss").should == 1 end end @@ -129,88 +127,84 @@ describe "String#casecmp independent of case" do end end -ruby_version_is "2.4" do - describe 'String#casecmp? independent of case' do - it 'returns true when equal to other' do - 'abc'.casecmp?('abc').should == true - 'abc'.casecmp?('ABC').should == true - end +describe 'String#casecmp? independent of case' do + it 'returns true when equal to other' do + 'abc'.casecmp?('abc').should == true + 'abc'.casecmp?('ABC').should == true + end - it 'returns false when not equal to other' do - 'abc'.casecmp?('DEF').should == false - 'abc'.casecmp?('def').should == false - end + it 'returns false when not equal to other' do + 'abc'.casecmp?('DEF').should == false + 'abc'.casecmp?('def').should == false + end + + it "tries to convert other to string using to_str" do + other = mock('x') + other.should_receive(:to_str).and_return("abc") - it "tries to convert other to string using to_str" do - other = mock('x') - other.should_receive(:to_str).and_return("abc") + "abc".casecmp?(other).should == true + end + + it "returns nil if incompatible encodings" do + "あれ".casecmp?("れ".encode(Encoding::EUC_JP)).should be_nil + end - "abc".casecmp?(other).should == true + describe 'for UNICODE characters' do + it 'returns true when downcase(:fold) on unicode' do + 'äöü'.casecmp?('ÄÖÜ').should == true end + end - it "returns nil if incompatible encodings" do - "あれ".casecmp?("れ".encode(Encoding::EUC_JP)).should be_nil + describe "when comparing a subclass instance" do + it 'returns true when equal to other' do + a = StringSpecs::MyString.new "a" + 'a'.casecmp?(a).should == true + 'A'.casecmp?(a).should == true end - describe 'for UNICODE characters' do - it 'returns true when downcase(:fold) on unicode' do - 'äöü'.casecmp?('ÄÖÜ').should == true - end + it 'returns false when not equal to other' do + b = StringSpecs::MyString.new "a" + 'b'.casecmp?(b).should == false + 'B'.casecmp?(b).should == false end + end - describe "when comparing a subclass instance" do - it 'returns true when equal to other' do - a = StringSpecs::MyString.new "a" - 'a'.casecmp?(a).should == true - 'A'.casecmp?(a).should == true + describe "in UTF-8 mode" do + describe "for non-ASCII characters" do + before :each do + @upper_a_tilde = "Ã" + @lower_a_tilde = "ã" + @upper_a_umlaut = "Ä" + @lower_a_umlaut = "ä" end - it 'returns false when not equal to other' do - b = StringSpecs::MyString.new "a" - 'b'.casecmp?(b).should == false - 'B'.casecmp?(b).should == false + it "returns true when they are the same with normalized case" do + @upper_a_tilde.casecmp?(@lower_a_tilde).should == true end - end - - describe "in UTF-8 mode" do - describe "for non-ASCII characters" do - before :each do - @upper_a_tilde = "Ã" - @lower_a_tilde = "ã" - @upper_a_umlaut = "Ä" - @lower_a_umlaut = "ä" - end - - it "returns true when they are the same with normalized case" do - @upper_a_tilde.casecmp?(@lower_a_tilde).should == true - end - - it "returns false when they are unrelated" do - @upper_a_tilde.casecmp?(@upper_a_umlaut).should == false - end - it "returns true when they have the same bytes" do - @upper_a_tilde.casecmp?(@upper_a_tilde).should == true - end + it "returns false when they are unrelated" do + @upper_a_tilde.casecmp?(@upper_a_umlaut).should == false end - end - ruby_version_is "2.4" do - it "case folds" do - "ß".casecmp?("ss").should be_true + it "returns true when they have the same bytes" do + @upper_a_tilde.casecmp?(@upper_a_tilde).should == true end end + end - ruby_version_is "2.4" ... "2.5" do - it "raises a TypeError if other can't be converted to a string" do - lambda { "abc".casecmp?(mock('abc')) }.should raise_error(TypeError) - end + it "case folds" do + "ß".casecmp?("ss").should be_true + end + + ruby_version_is "2.4"..."2.5" do + it "raises a TypeError if other can't be converted to a string" do + lambda { "abc".casecmp?(mock('abc')) }.should raise_error(TypeError) end + end - ruby_version_is "2.5" do - it "returns nil if other can't be converted to a string" do - "abc".casecmp?(mock('abc')).should be_nil - end + ruby_version_is "2.5" do + it "returns nil if other can't be converted to a string" do + "abc".casecmp?(mock('abc')).should be_nil end end end diff --git a/spec/ruby/core/string/concat_spec.rb b/spec/ruby/core/string/concat_spec.rb index 27917d6c85..5f6daadad7 100644 --- a/spec/ruby/core/string/concat_spec.rb +++ b/spec/ruby/core/string/concat_spec.rb @@ -6,23 +6,21 @@ describe "String#concat" do it_behaves_like :string_concat, :concat it_behaves_like :string_concat_encoding, :concat - ruby_version_is "2.4" do - it "takes multiple arguments" do - str = "hello " - str.concat "wo", "", "rld" - str.should == "hello world" - end + it "takes multiple arguments" do + str = "hello " + str.concat "wo", "", "rld" + str.should == "hello world" + end - it "concatenates the initial value when given arguments contain 2 self" do - str = "hello" - str.concat str, str - str.should == "hellohellohello" - end + it "concatenates the initial value when given arguments contain 2 self" do + str = "hello" + str.concat str, str + str.should == "hellohellohello" + end - it "returns self when given no arguments" do - str = "hello" - str.concat.should equal(str) - str.should == "hello" - end + it "returns self when given no arguments" do + str = "hello" + str.concat.should equal(str) + str.should == "hello" end end diff --git a/spec/ruby/core/string/downcase_spec.rb b/spec/ruby/core/string/downcase_spec.rb index 9fb93902b1..241bd8c147 100644 --- a/spec/ruby/core/string/downcase_spec.rb +++ b/spec/ruby/core/string/downcase_spec.rb @@ -8,82 +8,66 @@ describe "String#downcase" do "hello".downcase.should == "hello" end - ruby_version_is ''...'2.4' do - it "is locale insensitive (only replaces A-Z)" do - "ÄÖÜ".downcase.should == "ÄÖÜ" + describe "full Unicode case mapping" do + it "works for all of Unicode with no option" do + "ÄÖÜ".downcase.should == "äöü" + end - str = Array.new(256) { |c| c.chr }.join - expected = Array.new(256) do |i| - c = i.chr - c.between?("A", "Z") ? c.downcase : c - end.join + it "updates string metadata" do + downcased = "\u{212A}ING".downcase - str.downcase.should == expected + downcased.should == "king" + downcased.size.should == 4 + downcased.bytesize.should == 4 + downcased.ascii_only?.should be_true end end - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "works for all of Unicode with no option" do - "ÄÖÜ".downcase.should == "äöü" - end - - it "updates string metadata" do - downcased = "\u{212A}ING".downcase - - downcased.should == "king" - downcased.size.should == 4 - downcased.bytesize.should == 4 - downcased.ascii_only?.should be_true - end + describe "ASCII-only case mapping" do + it "does not downcase non-ASCII characters" do + "CÅR".downcase(:ascii).should == "cÅr" end + end - describe "ASCII-only case mapping" do - it "does not downcase non-ASCII characters" do - "CÅR".downcase(:ascii).should == "cÅr" - end + describe "full Unicode case mapping adapted for Turkic languages" do + it "downcases characters according to Turkic semantics" do + "İ".downcase(:turkic).should == "i" end - describe "full Unicode case mapping adapted for Turkic languages" do - it "downcases characters according to Turkic semantics" do - "İ".downcase(:turkic).should == "i" - end - - it "allows Lithuanian as an extra option" do - "İ".downcase(:turkic, :lithuanian).should == "i" - end - - it "does not allow any other additional option" do - lambda { "İ".downcase(:turkic, :ascii) }.should raise_error(ArgumentError) - end + it "allows Lithuanian as an extra option" do + "İ".downcase(:turkic, :lithuanian).should == "i" end - describe "full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - "İS".downcase(:lithuanian).should == "i\u{307}s" - end + it "does not allow any other additional option" do + lambda { "İ".downcase(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - "İS".downcase(:lithuanian, :turkic).should == "is" - end + describe "full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + "İS".downcase(:lithuanian).should == "i\u{307}s" + end - it "does not allow any other additional option" do - lambda { "İS".downcase(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + it "allows Turkic as an extra option (and applies Turkic semantics)" do + "İS".downcase(:lithuanian, :turkic).should == "is" end - describe "case folding" do - it "case folds special characters" do - "ß".downcase.should == "ß" - "ß".downcase(:fold).should == "ss" - end + it "does not allow any other additional option" do + lambda { "İS".downcase(:lithuanian, :ascii) }.should raise_error(ArgumentError) end + end - it "does not allow invalid options" do - lambda { "ABC".downcase(:invalid_option) }.should raise_error(ArgumentError) + describe "case folding" do + it "case folds special characters" do + "ß".downcase.should == "ß" + "ß".downcase(:fold).should == "ss" end end + it "does not allow invalid options" do + lambda { "ABC".downcase(:invalid_option) }.should raise_error(ArgumentError) + end + it "taints result when self is tainted" do "".taint.downcase.tainted?.should == true "x".taint.downcase.tainted?.should == true @@ -102,83 +86,81 @@ describe "String#downcase!" do a.should == "hello" end - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "modifies self in place for all of Unicode with no option" do - a = "ÄÖÜ" - a.downcase! - a.should == "äöü" - end + describe "full Unicode case mapping" do + it "modifies self in place for all of Unicode with no option" do + a = "ÄÖÜ" + a.downcase! + a.should == "äöü" + end - it "updates string metadata" do - downcased = "\u{212A}ING" - downcased.downcase! + it "updates string metadata" do + downcased = "\u{212A}ING" + downcased.downcase! - downcased.should == "king" - downcased.size.should == 4 - downcased.bytesize.should == 4 - downcased.ascii_only?.should be_true - end + downcased.should == "king" + downcased.size.should == 4 + downcased.bytesize.should == 4 + downcased.ascii_only?.should be_true end + end - describe "ASCII-only case mapping" do - it "does not downcase non-ASCII characters" do - a = "CÅR" - a.downcase!(:ascii) - a.should == "cÅr" - end + describe "ASCII-only case mapping" do + it "does not downcase non-ASCII characters" do + a = "CÅR" + a.downcase!(:ascii) + a.should == "cÅr" end + end - describe "full Unicode case mapping adapted for Turkic languages" do - it "downcases characters according to Turkic semantics" do - a = "İ" - a.downcase!(:turkic) - a.should == "i" - end + describe "full Unicode case mapping adapted for Turkic languages" do + it "downcases characters according to Turkic semantics" do + a = "İ" + a.downcase!(:turkic) + a.should == "i" + end - it "allows Lithuanian as an extra option" do - a = "İ" - a.downcase!(:turkic, :lithuanian) - a.should == "i" - end + it "allows Lithuanian as an extra option" do + a = "İ" + a.downcase!(:turkic, :lithuanian) + a.should == "i" + end - it "does not allow any other additional option" do - lambda { a = "İ"; a.downcase!(:turkic, :ascii) }.should raise_error(ArgumentError) - end + it "does not allow any other additional option" do + lambda { a = "İ"; a.downcase!(:turkic, :ascii) }.should raise_error(ArgumentError) end + end - describe "full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - a = "İS" - a.downcase!(:lithuanian) - a.should == "i\u{307}s" - end + describe "full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + a = "İS" + a.downcase!(:lithuanian) + a.should == "i\u{307}s" + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - a = "İS" - a.downcase!(:lithuanian, :turkic) - a.should == "is" - end + it "allows Turkic as an extra option (and applies Turkic semantics)" do + a = "İS" + a.downcase!(:lithuanian, :turkic) + a.should == "is" + end - it "does not allow any other additional option" do - lambda { a = "İS"; a.downcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + it "does not allow any other additional option" do + lambda { a = "İS"; a.downcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError) end + end - describe "case folding" do - it "case folds special characters" do - a = "ß" - a.downcase! - a.should == "ß" + describe "case folding" do + it "case folds special characters" do + a = "ß" + a.downcase! + a.should == "ß" - a.downcase!(:fold) - a.should == "ss" - end + a.downcase!(:fold) + a.should == "ss" end + end - it "does not allow invalid options" do - lambda { a = "ABC"; a.downcase!(:invalid_option) }.should raise_error(ArgumentError) - end + it "does not allow invalid options" do + lambda { a = "ABC"; a.downcase!(:invalid_option) }.should raise_error(ArgumentError) end it "returns nil if no modifications were made" do diff --git a/spec/ruby/core/string/dump_spec.rb b/spec/ruby/core/string/dump_spec.rb index e67367b5b0..aa91114893 100644 --- a/spec/ruby/core/string/dump_spec.rb +++ b/spec/ruby/core/string/dump_spec.rb @@ -352,78 +352,39 @@ describe "String#dump" do ].should be_computed_by(:dump) end - ruby_version_is ''...'2.4' do - it "returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with lower-case hex digits" do - [ [0200.chr('utf-8'), '"\u{80}"'], - [0201.chr('utf-8'), '"\u{81}"'], - [0202.chr('utf-8'), '"\u{82}"'], - [0203.chr('utf-8'), '"\u{83}"'], - [0204.chr('utf-8'), '"\u{84}"'], - [0206.chr('utf-8'), '"\u{86}"'], - [0207.chr('utf-8'), '"\u{87}"'], - [0210.chr('utf-8'), '"\u{88}"'], - [0211.chr('utf-8'), '"\u{89}"'], - [0212.chr('utf-8'), '"\u{8a}"'], - [0213.chr('utf-8'), '"\u{8b}"'], - [0214.chr('utf-8'), '"\u{8c}"'], - [0215.chr('utf-8'), '"\u{8d}"'], - [0216.chr('utf-8'), '"\u{8e}"'], - [0217.chr('utf-8'), '"\u{8f}"'], - [0220.chr('utf-8'), '"\u{90}"'], - [0221.chr('utf-8'), '"\u{91}"'], - [0222.chr('utf-8'), '"\u{92}"'], - [0223.chr('utf-8'), '"\u{93}"'], - [0224.chr('utf-8'), '"\u{94}"'], - [0225.chr('utf-8'), '"\u{95}"'], - [0226.chr('utf-8'), '"\u{96}"'], - [0227.chr('utf-8'), '"\u{97}"'], - [0230.chr('utf-8'), '"\u{98}"'], - [0231.chr('utf-8'), '"\u{99}"'], - [0232.chr('utf-8'), '"\u{9a}"'], - [0233.chr('utf-8'), '"\u{9b}"'], - [0234.chr('utf-8'), '"\u{9c}"'], - [0235.chr('utf-8'), '"\u{9d}"'], - [0236.chr('utf-8'), '"\u{9e}"'], - [0237.chr('utf-8'), '"\u{9f}"'], - ].should be_computed_by(:dump) - end - end - - ruby_version_is '2.4' do - it "returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with upper-case hex digits" do - [ [0200.chr('utf-8'), '"\u0080"'], - [0201.chr('utf-8'), '"\u0081"'], - [0202.chr('utf-8'), '"\u0082"'], - [0203.chr('utf-8'), '"\u0083"'], - [0204.chr('utf-8'), '"\u0084"'], - [0206.chr('utf-8'), '"\u0086"'], - [0207.chr('utf-8'), '"\u0087"'], - [0210.chr('utf-8'), '"\u0088"'], - [0211.chr('utf-8'), '"\u0089"'], - [0212.chr('utf-8'), '"\u008A"'], - [0213.chr('utf-8'), '"\u008B"'], - [0214.chr('utf-8'), '"\u008C"'], - [0215.chr('utf-8'), '"\u008D"'], - [0216.chr('utf-8'), '"\u008E"'], - [0217.chr('utf-8'), '"\u008F"'], - [0220.chr('utf-8'), '"\u0090"'], - [0221.chr('utf-8'), '"\u0091"'], - [0222.chr('utf-8'), '"\u0092"'], - [0223.chr('utf-8'), '"\u0093"'], - [0224.chr('utf-8'), '"\u0094"'], - [0225.chr('utf-8'), '"\u0095"'], - [0226.chr('utf-8'), '"\u0096"'], - [0227.chr('utf-8'), '"\u0097"'], - [0230.chr('utf-8'), '"\u0098"'], - [0231.chr('utf-8'), '"\u0099"'], - [0232.chr('utf-8'), '"\u009A"'], - [0233.chr('utf-8'), '"\u009B"'], - [0234.chr('utf-8'), '"\u009C"'], - [0235.chr('utf-8'), '"\u009D"'], - [0236.chr('utf-8'), '"\u009E"'], - [0237.chr('utf-8'), '"\u009F"'], - ].should be_computed_by(:dump) - end + it "returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with upper-case hex digits" do + [ [0200.chr('utf-8'), '"\u0080"'], + [0201.chr('utf-8'), '"\u0081"'], + [0202.chr('utf-8'), '"\u0082"'], + [0203.chr('utf-8'), '"\u0083"'], + [0204.chr('utf-8'), '"\u0084"'], + [0206.chr('utf-8'), '"\u0086"'], + [0207.chr('utf-8'), '"\u0087"'], + [0210.chr('utf-8'), '"\u0088"'], + [0211.chr('utf-8'), '"\u0089"'], + [0212.chr('utf-8'), '"\u008A"'], + [0213.chr('utf-8'), '"\u008B"'], + [0214.chr('utf-8'), '"\u008C"'], + [0215.chr('utf-8'), '"\u008D"'], + [0216.chr('utf-8'), '"\u008E"'], + [0217.chr('utf-8'), '"\u008F"'], + [0220.chr('utf-8'), '"\u0090"'], + [0221.chr('utf-8'), '"\u0091"'], + [0222.chr('utf-8'), '"\u0092"'], + [0223.chr('utf-8'), '"\u0093"'], + [0224.chr('utf-8'), '"\u0094"'], + [0225.chr('utf-8'), '"\u0095"'], + [0226.chr('utf-8'), '"\u0096"'], + [0227.chr('utf-8'), '"\u0097"'], + [0230.chr('utf-8'), '"\u0098"'], + [0231.chr('utf-8'), '"\u0099"'], + [0232.chr('utf-8'), '"\u009A"'], + [0233.chr('utf-8'), '"\u009B"'], + [0234.chr('utf-8'), '"\u009C"'], + [0235.chr('utf-8'), '"\u009D"'], + [0236.chr('utf-8'), '"\u009E"'], + [0237.chr('utf-8'), '"\u009F"'], + ].should be_computed_by(:dump) end it "includes .force_encoding(name) if the encoding isn't ASCII compatible" do diff --git a/spec/ruby/core/string/lines_spec.rb b/spec/ruby/core/string/lines_spec.rb index 1c13936c30..ad4b119074 100644 --- a/spec/ruby/core/string/lines_spec.rb +++ b/spec/ruby/core/string/lines_spec.rb @@ -11,12 +11,10 @@ describe "String#lines" do ary.should == ["hello ", "world"] end - ruby_version_is '2.4' do - context "when `chomp` keyword argument is passed" do - it "removes new line characters" do - "hello \nworld\n".lines(chomp: true).should == ["hello ", "world"] - "hello \r\nworld\r\n".lines(chomp: true).should == ["hello ", "world"] - end + context "when `chomp` keyword argument is passed" do + it "removes new line characters" do + "hello \nworld\n".lines(chomp: true).should == ["hello ", "world"] + "hello \r\nworld\r\n".lines(chomp: true).should == ["hello ", "world"] end end end diff --git a/spec/ruby/core/string/match_spec.rb b/spec/ruby/core/string/match_spec.rb index 7f3d9ebae5..67e015f23d 100644 --- a/spec/ruby/core/string/match_spec.rb +++ b/spec/ruby/core/string/match_spec.rb @@ -149,27 +149,25 @@ describe "String#match" do end end -ruby_version_is "2.4" do - describe "String#match?" do - before :each do - # Resetting Regexp.last_match - /DONTMATCH/.match '' - end +describe "String#match?" do + before :each do + # Resetting Regexp.last_match + /DONTMATCH/.match '' + end - context "when matches the given regex" do - it "returns true but does not set Regexp.last_match" do - 'string'.match?(/string/i).should be_true - Regexp.last_match.should be_nil - end + context "when matches the given regex" do + it "returns true but does not set Regexp.last_match" do + 'string'.match?(/string/i).should be_true + Regexp.last_match.should be_nil end + end - it "returns false when does not match the given regex" do - 'string'.match?(/STRING/).should be_false - end + it "returns false when does not match the given regex" do + 'string'.match?(/STRING/).should be_false + end - it "takes matching position as the 2nd argument" do - 'string'.match?(/str/i, 0).should be_true - 'string'.match?(/str/i, 1).should be_false - end + it "takes matching position as the 2nd argument" do + 'string'.match?(/str/i, 0).should be_true + 'string'.match?(/str/i, 1).should be_false end end diff --git a/spec/ruby/core/string/new_spec.rb b/spec/ruby/core/string/new_spec.rb index a65c6da2d1..f65daf2dd2 100644 --- a/spec/ruby/core/string/new_spec.rb +++ b/spec/ruby/core/string/new_spec.rb @@ -13,11 +13,9 @@ describe "String.new" do str.encoding.should == Encoding::EUC_JP end - ruby_version_is "2.4" do - it "accepts a capacity argument" do - String.new("", capacity: 100_000).should == "" - String.new("abc", capacity: 100_000).should == "abc" - end + it "accepts a capacity argument" do + String.new("", capacity: 100_000).should == "" + String.new("abc", capacity: 100_000).should == "abc" end it "returns a fully-formed String" do diff --git a/spec/ruby/core/string/prepend_spec.rb b/spec/ruby/core/string/prepend_spec.rb index cbe83524b8..e2c29de836 100644 --- a/spec/ruby/core/string/prepend_spec.rb +++ b/spec/ruby/core/string/prepend_spec.rb @@ -42,23 +42,21 @@ describe "String#prepend" do x.prepend("y".taint).tainted?.should be_true end - ruby_version_is "2.4" do - it "takes multiple arguments" do - str = " world" - str.prepend "he", "", "llo" - str.should == "hello world" - end + it "takes multiple arguments" do + str = " world" + str.prepend "he", "", "llo" + str.should == "hello world" + end - it "prepends the initial value when given arguments contain 2 self" do - str = "hello" - str.prepend str, str - str.should == "hellohellohello" - end + it "prepends the initial value when given arguments contain 2 self" do + str = "hello" + str.prepend str, str + str.should == "hellohellohello" + end - it "returns self when given no arguments" do - str = "hello" - str.prepend.should equal(str) - str.should == "hello" - end + it "returns self when given no arguments" do + str = "hello" + str.prepend.should equal(str) + str.should == "hello" end end diff --git a/spec/ruby/core/string/shared/each_line.rb b/spec/ruby/core/string/shared/each_line.rb index 066b0c1040..86c966e50b 100644 --- a/spec/ruby/core/string/shared/each_line.rb +++ b/spec/ruby/core/string/shared/each_line.rb @@ -145,34 +145,32 @@ describe :string_each_line, shared: true do lambda { "hello world".send(@method, :o).to_a }.should raise_error(TypeError) end - ruby_version_is '2.4' do - context "when `chomp` keyword argument is passed" do - it "removes new line characters when separator is not specified" do - a = [] - "hello \nworld\n".send(@method, chomp: true) { |s| a << s } - a.should == ["hello ", "world"] - - a = [] - "hello \r\nworld\r\n".send(@method, chomp: true) { |s| a << s } - a.should == ["hello ", "world"] - end + context "when `chomp` keyword argument is passed" do + it "removes new line characters when separator is not specified" do + a = [] + "hello \nworld\n".send(@method, chomp: true) { |s| a << s } + a.should == ["hello ", "world"] - it "removes only specified separator" do - a = [] - "hello world".send(@method, ' ', chomp: true) { |s| a << s } - a.should == ["hello", "world"] - end + a = [] + "hello \r\nworld\r\n".send(@method, chomp: true) { |s| a << s } + a.should == ["hello ", "world"] + end - # https://bugs.ruby-lang.org/issues/14257 - it "ignores new line characters when separator is specified" do - a = [] - "hello\n world\n".send(@method, ' ', chomp: true) { |s| a << s } - a.should == ["hello\n", "world\n"] + it "removes only specified separator" do + a = [] + "hello world".send(@method, ' ', chomp: true) { |s| a << s } + a.should == ["hello", "world"] + end - a = [] - "hello\r\n world\r\n".send(@method, ' ', chomp: true) { |s| a << s } - a.should == ["hello\r\n", "world\r\n"] - end + # https://bugs.ruby-lang.org/issues/14257 + it "ignores new line characters when separator is specified" do + a = [] + "hello\n world\n".send(@method, ' ', chomp: true) { |s| a << s } + a.should == ["hello\n", "world\n"] + + a = [] + "hello\r\n world\r\n".send(@method, ' ', chomp: true) { |s| a << s } + a.should == ["hello\r\n", "world\r\n"] end end end diff --git a/spec/ruby/core/string/split_spec.rb b/spec/ruby/core/string/split_spec.rb index 7d5a591790..82f261b8df 100644 --- a/spec/ruby/core/string/split_spec.rb +++ b/spec/ruby/core/string/split_spec.rb @@ -65,28 +65,26 @@ describe "String#split with String" do end it "defaults to $; when string isn't given or nil" do - begin - verbose = $VERBOSE - $VERBOSE = nil + suppress_warning do old_fs = $; + begin + [",", ":", "", "XY", nil].each do |fs| + $; = fs - [",", ":", "", "XY", nil].each do |fs| - $; = fs + ["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str| + expected = str.split(fs || " ") - ["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str| - expected = str.split(fs || " ") + str.split(nil).should == expected + str.split.should == expected - str.split(nil).should == expected - str.split.should == expected - - str.split(nil, -1).should == str.split(fs || " ", -1) - str.split(nil, 0).should == str.split(fs || " ", 0) - str.split(nil, 2).should == str.split(fs || " ", 2) + str.split(nil, -1).should == str.split(fs || " ", -1) + str.split(nil, 0).should == str.split(fs || " ", 0) + str.split(nil, 2).should == str.split(fs || " ", 2) + end end + ensure + $; = old_fs end - ensure - $; = old_fs - $VERBOSE = verbose end end @@ -241,28 +239,26 @@ describe "String#split with Regexp" do end it "defaults to $; when regexp isn't given or nil" do - begin - verbose = $VERBOSE - $VERBOSE = nil + suppress_warning do old_fs = $; + begin + [/,/, /:/, //, /XY/, /./].each do |fs| + $; = fs - [/,/, /:/, //, /XY/, /./].each do |fs| - $; = fs + ["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str| + expected = str.split(fs) - ["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str| - expected = str.split(fs) + str.split(nil).should == expected + str.split.should == expected - str.split(nil).should == expected - str.split.should == expected - - str.split(nil, -1).should == str.split(fs, -1) - str.split(nil, 0).should == str.split(fs, 0) - str.split(nil, 2).should == str.split(fs, 2) + str.split(nil, -1).should == str.split(fs, -1) + str.split(nil, 0).should == str.split(fs, 0) + str.split(nil, 2).should == str.split(fs, 2) + end end + ensure + $; = old_fs end - ensure - $; = old_fs - $VERBOSE = verbose end end diff --git a/spec/ruby/core/string/swapcase_spec.rb b/spec/ruby/core/string/swapcase_spec.rb index bb89dee48f..c35751859e 100644 --- a/spec/ruby/core/string/swapcase_spec.rb +++ b/spec/ruby/core/string/swapcase_spec.rb @@ -14,73 +14,63 @@ describe "String#swapcase" do "hello".taint.swapcase.tainted?.should == true end - ruby_version_is ''...'2.4' do - it "is locale insensitive (only upcases a-z and only downcases A-Z)" do - "ÄÖÜ".swapcase.should == "ÄÖÜ" - "ärger".swapcase.should == "äRGER" - "BÄR".swapcase.should == "bÄr" + describe "full Unicode case mapping" do + it "works for all of Unicode with no option" do + "äÖü".swapcase.should == "ÄöÜ" end - end - - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "works for all of Unicode with no option" do - "äÖü".swapcase.should == "ÄöÜ" - end - it "updates string metadata" do - swapcased = "Aßet".swapcase + it "updates string metadata" do + swapcased = "Aßet".swapcase - swapcased.should == "aSSET" - swapcased.size.should == 5 - swapcased.bytesize.should == 5 - swapcased.ascii_only?.should be_true - end + swapcased.should == "aSSET" + swapcased.size.should == 5 + swapcased.bytesize.should == 5 + swapcased.ascii_only?.should be_true end + end - describe "ASCII-only case mapping" do - it "does not swapcase non-ASCII characters" do - "aßet".swapcase(:ascii).should == "AßET" - end + describe "ASCII-only case mapping" do + it "does not swapcase non-ASCII characters" do + "aßet".swapcase(:ascii).should == "AßET" end + end - describe "full Unicode case mapping adapted for Turkic languages" do - it "swaps case of ASCII characters according to Turkic semantics" do - "aiS".swapcase(:turkic).should == "Aİs" - end - - it "allows Lithuanian as an extra option" do - "aiS".swapcase(:turkic, :lithuanian).should == "Aİs" - end - - it "does not allow any other additional option" do - lambda { "aiS".swapcase(:turkic, :ascii) }.should raise_error(ArgumentError) - end + describe "full Unicode case mapping adapted for Turkic languages" do + it "swaps case of ASCII characters according to Turkic semantics" do + "aiS".swapcase(:turkic).should == "Aİs" end - describe "full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - "Iß".swapcase(:lithuanian).should == "iSS" - end + it "allows Lithuanian as an extra option" do + "aiS".swapcase(:turkic, :lithuanian).should == "Aİs" + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - "iS".swapcase(:lithuanian, :turkic).should == "İs" - end + it "does not allow any other additional option" do + lambda { "aiS".swapcase(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "does not allow any other additional option" do - lambda { "aiS".swapcase(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + describe "full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + "Iß".swapcase(:lithuanian).should == "iSS" end - it "does not allow the :fold option for upcasing" do - lambda { "abc".swapcase(:fold) }.should raise_error(ArgumentError) + it "allows Turkic as an extra option (and applies Turkic semantics)" do + "iS".swapcase(:lithuanian, :turkic).should == "İs" end - it "does not allow invalid options" do - lambda { "abc".swapcase(:invalid_option) }.should raise_error(ArgumentError) + it "does not allow any other additional option" do + lambda { "aiS".swapcase(:lithuanian, :ascii) }.should raise_error(ArgumentError) end end + it "does not allow the :fold option for upcasing" do + lambda { "abc".swapcase(:fold) }.should raise_error(ArgumentError) + end + + it "does not allow invalid options" do + lambda { "abc".swapcase(:invalid_option) }.should raise_error(ArgumentError) + end + it "returns subclass instances when called on a subclass" do StringSpecs::MyString.new("").swapcase.should be_an_instance_of(StringSpecs::MyString) StringSpecs::MyString.new("hello").swapcase.should be_an_instance_of(StringSpecs::MyString) @@ -94,78 +84,76 @@ describe "String#swapcase!" do a.should == "CyBeR_pUnK11" end - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "modifies self in place for all of Unicode with no option" do - a = "äÖü" - a.swapcase! - a.should == "ÄöÜ" - end + describe "full Unicode case mapping" do + it "modifies self in place for all of Unicode with no option" do + a = "äÖü" + a.swapcase! + a.should == "ÄöÜ" + end - it "updates string metadata" do - swapcased = "Aßet" - swapcased.swapcase! + it "updates string metadata" do + swapcased = "Aßet" + swapcased.swapcase! - swapcased.should == "aSSET" - swapcased.size.should == 5 - swapcased.bytesize.should == 5 - swapcased.ascii_only?.should be_true - end + swapcased.should == "aSSET" + swapcased.size.should == 5 + swapcased.bytesize.should == 5 + swapcased.ascii_only?.should be_true end + end - describe "modifies self in place for ASCII-only case mapping" do - it "does not swapcase non-ASCII characters" do - a = "aßet" - a.swapcase!(:ascii) - a.should == "AßET" - end + describe "modifies self in place for ASCII-only case mapping" do + it "does not swapcase non-ASCII characters" do + a = "aßet" + a.swapcase!(:ascii) + a.should == "AßET" end + end - describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do - it "swaps case of ASCII characters according to Turkic semantics" do - a = "aiS" - a.swapcase!(:turkic) - a.should == "Aİs" - end - - it "allows Lithuanian as an extra option" do - a = "aiS" - a.swapcase!(:turkic, :lithuanian) - a.should == "Aİs" - end - - it "does not allow any other additional option" do - lambda { a = "aiS"; a.swapcase!(:turkic, :ascii) }.should raise_error(ArgumentError) - end + describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do + it "swaps case of ASCII characters according to Turkic semantics" do + a = "aiS" + a.swapcase!(:turkic) + a.should == "Aİs" end - describe "full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - a = "Iß" - a.swapcase!(:lithuanian) - a.should == "iSS" - end + it "allows Lithuanian as an extra option" do + a = "aiS" + a.swapcase!(:turkic, :lithuanian) + a.should == "Aİs" + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - a = "iS" - a.swapcase!(:lithuanian, :turkic) - a.should == "İs" - end + it "does not allow any other additional option" do + lambda { a = "aiS"; a.swapcase!(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "does not allow any other additional option" do - lambda { a = "aiS"; a.swapcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + describe "full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + a = "Iß" + a.swapcase!(:lithuanian) + a.should == "iSS" end - it "does not allow the :fold option for upcasing" do - lambda { a = "abc"; a.swapcase!(:fold) }.should raise_error(ArgumentError) + it "allows Turkic as an extra option (and applies Turkic semantics)" do + a = "iS" + a.swapcase!(:lithuanian, :turkic) + a.should == "İs" end - it "does not allow invalid options" do - lambda { a = "abc"; a.swapcase!(:invalid_option) }.should raise_error(ArgumentError) + it "does not allow any other additional option" do + lambda { a = "aiS"; a.swapcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError) end end + it "does not allow the :fold option for upcasing" do + lambda { a = "abc"; a.swapcase!(:fold) }.should raise_error(ArgumentError) + end + + it "does not allow invalid options" do + lambda { a = "abc"; a.swapcase!(:invalid_option) }.should raise_error(ArgumentError) + end + it "returns nil if no modifications were made" do a = "+++---111222???" a.swapcase!.should == nil diff --git a/spec/ruby/core/string/to_f_spec.rb b/spec/ruby/core/string/to_f_spec.rb index ca8536c30e..cf64ecfc5d 100644 --- a/spec/ruby/core/string/to_f_spec.rb +++ b/spec/ruby/core/string/to_f_spec.rb @@ -12,6 +12,7 @@ describe "String#to_f" do ".5".to_f.should == 0.5 ".5e1".to_f.should == 5.0 + "5.".to_f.should == 5.0 "5e".to_f.should == 5.0 "5E".to_f.should == 5.0 end diff --git a/spec/ruby/core/string/unpack1_spec.rb b/spec/ruby/core/string/unpack1_spec.rb index 5b2157d85a..5fe81733fb 100644 --- a/spec/ruby/core/string/unpack1_spec.rb +++ b/spec/ruby/core/string/unpack1_spec.rb @@ -1,12 +1,10 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "String#unpack1" do - it "returns the first value of #unpack" do - "ABCD".unpack1('x3C').should == "ABCD".unpack('x3C')[0] - "\u{3042 3044 3046}".unpack1("U*").should == 0x3042 - "aG9nZWZ1Z2E=".unpack1("m").should == "hogefuga" - "A".unpack1("B*").should == "01000001" - end +describe "String#unpack1" do + it "returns the first value of #unpack" do + "ABCD".unpack1('x3C').should == "ABCD".unpack('x3C')[0] + "\u{3042 3044 3046}".unpack1("U*").should == 0x3042 + "aG9nZWZ1Z2E=".unpack1("m").should == "hogefuga" + "A".unpack1("B*").should == "01000001" end end diff --git a/spec/ruby/core/string/upcase_spec.rb b/spec/ruby/core/string/upcase_spec.rb index 347f567be9..eb736ebfa1 100644 --- a/spec/ruby/core/string/upcase_spec.rb +++ b/spec/ruby/core/string/upcase_spec.rb @@ -8,79 +8,63 @@ describe "String#upcase" do "hello".upcase.should == "HELLO" end - ruby_version_is ''...'2.4' do - it "is locale insensitive (only replaces a-z)" do - "äöü".upcase.should == "äöü" + describe "full Unicode case mapping" do + it "works for all of Unicode with no option" do + "äöü".upcase.should == "ÄÖÜ" + end - str = Array.new(256) { |c| c.chr }.join - expected = Array.new(256) do |i| - c = i.chr - c.between?("a", "z") ? c.upcase : c - end.join + it "updates string metadata" do + upcased = "aßet".upcase - str.upcase.should == expected + upcased.should == "ASSET" + upcased.size.should == 5 + upcased.bytesize.should == 5 + upcased.ascii_only?.should be_true end end - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "works for all of Unicode with no option" do - "äöü".upcase.should == "ÄÖÜ" - end - - it "updates string metadata" do - upcased = "aßet".upcase - - upcased.should == "ASSET" - upcased.size.should == 5 - upcased.bytesize.should == 5 - upcased.ascii_only?.should be_true - end + describe "ASCII-only case mapping" do + it "does not upcase non-ASCII characters" do + "aßet".upcase(:ascii).should == "AßET" end + end - describe "ASCII-only case mapping" do - it "does not upcase non-ASCII characters" do - "aßet".upcase(:ascii).should == "AßET" - end + describe "full Unicode case mapping adapted for Turkic languages" do + it "upcases ASCII characters according to Turkic semantics" do + "i".upcase(:turkic).should == "İ" end - describe "full Unicode case mapping adapted for Turkic languages" do - it "upcases ASCII characters according to Turkic semantics" do - "i".upcase(:turkic).should == "İ" - end - - it "allows Lithuanian as an extra option" do - "i".upcase(:turkic, :lithuanian).should == "İ" - end - - it "does not allow any other additional option" do - lambda { "i".upcase(:turkic, :ascii) }.should raise_error(ArgumentError) - end + it "allows Lithuanian as an extra option" do + "i".upcase(:turkic, :lithuanian).should == "İ" end - describe "full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - "iß".upcase(:lithuanian).should == "ISS" - end - - it "allows Turkic as an extra option (and applies Turkic semantics)" do - "iß".upcase(:lithuanian, :turkic).should == "İSS" - end + it "does not allow any other additional option" do + lambda { "i".upcase(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "does not allow any other additional option" do - lambda { "iß".upcase(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + describe "full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + "iß".upcase(:lithuanian).should == "ISS" end - it "does not allow the :fold option for upcasing" do - lambda { "abc".upcase(:fold) }.should raise_error(ArgumentError) + it "allows Turkic as an extra option (and applies Turkic semantics)" do + "iß".upcase(:lithuanian, :turkic).should == "İSS" end - it "does not allow invalid options" do - lambda { "abc".upcase(:invalid_option) }.should raise_error(ArgumentError) + it "does not allow any other additional option" do + lambda { "iß".upcase(:lithuanian, :ascii) }.should raise_error(ArgumentError) end end + it "does not allow the :fold option for upcasing" do + lambda { "abc".upcase(:fold) }.should raise_error(ArgumentError) + end + + it "does not allow invalid options" do + lambda { "abc".upcase(:invalid_option) }.should raise_error(ArgumentError) + end + it "taints result when self is tainted" do "".taint.upcase.tainted?.should == true "X".taint.upcase.tainted?.should == true @@ -99,78 +83,76 @@ describe "String#upcase!" do a.should == "HELLO" end - ruby_version_is '2.4' do - describe "full Unicode case mapping" do - it "modifies self in place for all of Unicode with no option" do - a = "äöü" - a.upcase! - a.should == "ÄÖÜ" - end + describe "full Unicode case mapping" do + it "modifies self in place for all of Unicode with no option" do + a = "äöü" + a.upcase! + a.should == "ÄÖÜ" + end - it "updates string metadata for self" do - upcased = "aßet" - upcased.upcase! + it "updates string metadata for self" do + upcased = "aßet" + upcased.upcase! - upcased.should == "ASSET" - upcased.size.should == 5 - upcased.bytesize.should == 5 - upcased.ascii_only?.should be_true - end + upcased.should == "ASSET" + upcased.size.should == 5 + upcased.bytesize.should == 5 + upcased.ascii_only?.should be_true end + end - describe "modifies self in place for ASCII-only case mapping" do - it "does not upcase non-ASCII characters" do - a = "aßet" - a.upcase!(:ascii) - a.should == "AßET" - end + describe "modifies self in place for ASCII-only case mapping" do + it "does not upcase non-ASCII characters" do + a = "aßet" + a.upcase!(:ascii) + a.should == "AßET" end + end - describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do - it "upcases ASCII characters according to Turkic semantics" do - a = "i" - a.upcase!(:turkic) - a.should == "İ" - end - - it "allows Lithuanian as an extra option" do - a = "i" - a.upcase!(:turkic, :lithuanian) - a.should == "İ" - end - - it "does not allow any other additional option" do - lambda { a = "i"; a.upcase!(:turkic, :ascii) }.should raise_error(ArgumentError) - end + describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do + it "upcases ASCII characters according to Turkic semantics" do + a = "i" + a.upcase!(:turkic) + a.should == "İ" end - describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do - it "currently works the same as full Unicode case mapping" do - a = "iß" - a.upcase!(:lithuanian) - a.should == "ISS" - end + it "allows Lithuanian as an extra option" do + a = "i" + a.upcase!(:turkic, :lithuanian) + a.should == "İ" + end - it "allows Turkic as an extra option (and applies Turkic semantics)" do - a = "iß" - a.upcase!(:lithuanian, :turkic) - a.should == "İSS" - end + it "does not allow any other additional option" do + lambda { a = "i"; a.upcase!(:turkic, :ascii) }.should raise_error(ArgumentError) + end + end - it "does not allow any other additional option" do - lambda { a = "iß"; a.upcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError) - end + describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do + it "currently works the same as full Unicode case mapping" do + a = "iß" + a.upcase!(:lithuanian) + a.should == "ISS" end - it "does not allow the :fold option for upcasing" do - lambda { a = "abc"; a.upcase!(:fold) }.should raise_error(ArgumentError) + it "allows Turkic as an extra option (and applies Turkic semantics)" do + a = "iß" + a.upcase!(:lithuanian, :turkic) + a.should == "İSS" end - it "does not allow invalid options" do - lambda { a = "abc"; a.upcase!(:invalid_option) }.should raise_error(ArgumentError) + it "does not allow any other additional option" do + lambda { a = "iß"; a.upcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError) end end + it "does not allow the :fold option for upcasing" do + lambda { a = "abc"; a.upcase!(:fold) }.should raise_error(ArgumentError) + end + + it "does not allow invalid options" do + lambda { a = "abc"; a.upcase!(:invalid_option) }.should raise_error(ArgumentError) + end + it "returns nil if no modifications were made" do a = "HELLO" a.upcase!.should == nil diff --git a/spec/ruby/core/symbol/capitalize_spec.rb b/spec/ruby/core/symbol/capitalize_spec.rb index 54aebf21ca..a84bcf280a 100644 --- a/spec/ruby/core/symbol/capitalize_spec.rb +++ b/spec/ruby/core/symbol/capitalize_spec.rb @@ -14,18 +14,9 @@ describe "Symbol#capitalize" do :"£1.20".capitalize.should == :"£1.20" end - ruby_version_is ''...'2.4' do - it "leaves the first character alone if it is not an alphabetical ASCII character" do - "\u{00DE}c".to_sym.capitalize.should == :"Þc" - "\u{00DF}C".to_sym.capitalize.should == :"ßc" - end - end - - ruby_version_is '2.4' do - it "capitalizes the first character if it is Unicode" do - :"äöü".capitalize.should == :"Äöü" - :"aou".capitalize.should == :"Aou" - end + it "capitalizes the first character if it is Unicode" do + :"äöü".capitalize.should == :"Äöü" + :"aou".capitalize.should == :"Aou" end it "converts subsequent uppercase ASCII characters to their lowercase equivalents" do @@ -40,12 +31,6 @@ describe "Symbol#capitalize" do :mIxEd.capitalize.should == :Mixed end - ruby_version_is ''...'2.4' do - it "leaves uppercase Unicode characters as they were" do - "a\u{00DE}c".to_sym.capitalize.should == :"AÞc" - end - end - it "leaves lowercase Unicode characters (except in first position) as they were" do "a\u{00DF}C".to_sym.capitalize.should == :"Aßc" end diff --git a/spec/ruby/core/symbol/casecmp_spec.rb b/spec/ruby/core/symbol/casecmp_spec.rb index 232399b664..b485101d63 100644 --- a/spec/ruby/core/symbol/casecmp_spec.rb +++ b/spec/ruby/core/symbol/casecmp_spec.rb @@ -73,74 +73,72 @@ describe "Symbol#casecmp" do end end -ruby_version_is "2.4" do - describe 'Symbol#casecmp?' do - it "compares symbols without regard to case" do - :abcdef.casecmp?(:abcde).should == false - :aBcDeF.casecmp?(:abcdef).should == true - :abcdef.casecmp?(:abcdefg).should == false - :abcdef.casecmp?(:ABCDEF).should == true - end - - it "doesn't consider non-ascii characters equal that aren't" do - # -- Latin-1 -- - upper_a_tilde = "\xC3".b.to_sym - upper_a_umlaut = "\xC4".b.to_sym - lower_a_tilde = "\xE3".b.to_sym - lower_a_umlaut = "\xE4".b.to_sym - - lower_a_tilde.casecmp?(lower_a_umlaut).should_not == true - lower_a_umlaut.casecmp?(lower_a_tilde).should_not == true - upper_a_tilde.casecmp?(upper_a_umlaut).should_not == true - upper_a_umlaut.casecmp?(upper_a_tilde).should_not == true - - # -- UTF-8 -- - upper_a_tilde = :"Ã" - lower_a_tilde = :"ã" - upper_a_umlaut = :"Ä" - lower_a_umlaut = :"ä" - - lower_a_tilde.casecmp?(lower_a_umlaut).should_not == true - lower_a_umlaut.casecmp?(lower_a_tilde).should_not == true - upper_a_tilde.casecmp?(upper_a_umlaut).should_not == true - upper_a_umlaut.casecmp?(upper_a_tilde).should_not == true - end - - it "doesn't do case mapping for non-ascii and non-unicode characters" do - # -- Latin-1 -- - upper_a_tilde = "\xC3".b.to_sym - upper_a_umlaut = "\xC4".b.to_sym - lower_a_tilde = "\xE3".b.to_sym - lower_a_umlaut = "\xE4".b.to_sym - - upper_a_tilde.casecmp?(lower_a_tilde).should == false - upper_a_umlaut.casecmp?(lower_a_umlaut).should == false - lower_a_tilde.casecmp?(upper_a_tilde).should == false - lower_a_umlaut.casecmp?(upper_a_umlaut).should == false - end - - it 'does case mapping for unicode characters' do - # -- UTF-8 -- - upper_a_tilde = :"Ã" - lower_a_tilde = :"ã" - upper_a_umlaut = :"Ä" - lower_a_umlaut = :"ä" - - upper_a_tilde.casecmp?(lower_a_tilde).should == true - upper_a_umlaut.casecmp?(lower_a_umlaut).should == true - lower_a_tilde.casecmp?(upper_a_tilde).should == true - lower_a_umlaut.casecmp?(upper_a_umlaut).should == true - end - - it 'returns nil when comparing characters with different encodings' do - # -- Latin-1 -- - upper_a_tilde = "\xC3".b.to_sym - - # -- UTF-8 -- - lower_a_tilde = :"ã" - - upper_a_tilde.casecmp?(lower_a_tilde).should == nil - lower_a_tilde.casecmp?(upper_a_tilde).should == nil - end +describe 'Symbol#casecmp?' do + it "compares symbols without regard to case" do + :abcdef.casecmp?(:abcde).should == false + :aBcDeF.casecmp?(:abcdef).should == true + :abcdef.casecmp?(:abcdefg).should == false + :abcdef.casecmp?(:ABCDEF).should == true + end + + it "doesn't consider non-ascii characters equal that aren't" do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + upper_a_umlaut = "\xC4".b.to_sym + lower_a_tilde = "\xE3".b.to_sym + lower_a_umlaut = "\xE4".b.to_sym + + lower_a_tilde.casecmp?(lower_a_umlaut).should_not == true + lower_a_umlaut.casecmp?(lower_a_tilde).should_not == true + upper_a_tilde.casecmp?(upper_a_umlaut).should_not == true + upper_a_umlaut.casecmp?(upper_a_tilde).should_not == true + + # -- UTF-8 -- + upper_a_tilde = :"Ã" + lower_a_tilde = :"ã" + upper_a_umlaut = :"Ä" + lower_a_umlaut = :"ä" + + lower_a_tilde.casecmp?(lower_a_umlaut).should_not == true + lower_a_umlaut.casecmp?(lower_a_tilde).should_not == true + upper_a_tilde.casecmp?(upper_a_umlaut).should_not == true + upper_a_umlaut.casecmp?(upper_a_tilde).should_not == true + end + + it "doesn't do case mapping for non-ascii and non-unicode characters" do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + upper_a_umlaut = "\xC4".b.to_sym + lower_a_tilde = "\xE3".b.to_sym + lower_a_umlaut = "\xE4".b.to_sym + + upper_a_tilde.casecmp?(lower_a_tilde).should == false + upper_a_umlaut.casecmp?(lower_a_umlaut).should == false + lower_a_tilde.casecmp?(upper_a_tilde).should == false + lower_a_umlaut.casecmp?(upper_a_umlaut).should == false + end + + it 'does case mapping for unicode characters' do + # -- UTF-8 -- + upper_a_tilde = :"Ã" + lower_a_tilde = :"ã" + upper_a_umlaut = :"Ä" + lower_a_umlaut = :"ä" + + upper_a_tilde.casecmp?(lower_a_tilde).should == true + upper_a_umlaut.casecmp?(lower_a_umlaut).should == true + lower_a_tilde.casecmp?(upper_a_tilde).should == true + lower_a_umlaut.casecmp?(upper_a_umlaut).should == true + end + + it 'returns nil when comparing characters with different encodings' do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + + # -- UTF-8 -- + lower_a_tilde = :"ã" + + upper_a_tilde.casecmp?(lower_a_tilde).should == nil + lower_a_tilde.casecmp?(upper_a_tilde).should == nil end end diff --git a/spec/ruby/core/symbol/downcase_spec.rb b/spec/ruby/core/symbol/downcase_spec.rb index eb81c90d05..7e94c669cc 100644 --- a/spec/ruby/core/symbol/downcase_spec.rb +++ b/spec/ruby/core/symbol/downcase_spec.rb @@ -14,17 +14,9 @@ describe "Symbol#downcase" do "\u{E0}Bc".to_sym.downcase.should == :"àbc" end - ruby_version_is ''...'2.4' do - it "leaves uppercase Unicode characters as they were" do - "\u{DE}Bc".to_sym.downcase.should == :"Þbc" - end - end - - ruby_version_is '2.4' do - it "uncapitalizes all Unicode characters" do - "ÄÖÜ".to_sym.downcase.should == :"äöü" - "AOU".to_sym.downcase.should == :"aou" - end + it "uncapitalizes all Unicode characters" do + "ÄÖÜ".to_sym.downcase.should == :"äöü" + "AOU".to_sym.downcase.should == :"aou" end it "leaves non-alphabetic ASCII characters as they were" do diff --git a/spec/ruby/core/symbol/dup_spec.rb b/spec/ruby/core/symbol/dup_spec.rb index 202720e8f5..8b35917c27 100644 --- a/spec/ruby/core/symbol/dup_spec.rb +++ b/spec/ruby/core/symbol/dup_spec.rb @@ -1,9 +1,7 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "Symbol#dup" do - it "returns self" do - :a_symbol.dup.should equal(:a_symbol) - end +describe "Symbol#dup" do + it "returns self" do + :a_symbol.dup.should equal(:a_symbol) end end diff --git a/spec/ruby/core/symbol/match_spec.rb b/spec/ruby/core/symbol/match_spec.rb index c26d0569ed..d37155537b 100644 --- a/spec/ruby/core/symbol/match_spec.rb +++ b/spec/ruby/core/symbol/match_spec.rb @@ -19,52 +19,42 @@ describe "Symbol#=~" do it_behaves_like :symbol_match, :=~ end -ruby_version_is ""..."2.4" do - describe "Symbol#match" do - it_behaves_like :symbol_match, :match +describe "Symbol#match" do + it "returns the MatchData" do + result = :abc.match(/b/) + result.should be_kind_of(MatchData) + result[0].should == 'b' end -end - -ruby_version_is "2.4" do - describe "Symbol#match" do - it "returns the MatchData" do - result = :abc.match(/b/) - result.should be_kind_of(MatchData) - result[0].should == 'b' - end - it "returns nil if there is no match" do - :a.match(/b/).should be_nil - end + it "returns nil if there is no match" do + :a.match(/b/).should be_nil + end - it "sets the last match pseudo-variables" do - :a.match(/(.)/)[0].should == 'a' - $1.should == "a" - end + it "sets the last match pseudo-variables" do + :a.match(/(.)/)[0].should == 'a' + $1.should == "a" end end -ruby_version_is "2.4" do - describe "Symbol#match?" do - before :each do - # Resetting Regexp.last_match - /DONTMATCH/.match '' - end +describe "Symbol#match?" do + before :each do + # Resetting Regexp.last_match + /DONTMATCH/.match '' + end - context "when matches the given regex" do - it "returns true but does not set Regexp.last_match" do - :string.match?(/string/i).should be_true - Regexp.last_match.should be_nil - end + context "when matches the given regex" do + it "returns true but does not set Regexp.last_match" do + :string.match?(/string/i).should be_true + Regexp.last_match.should be_nil end + end - it "returns false when does not match the given regex" do - :string.match?(/STRING/).should be_false - end + it "returns false when does not match the given regex" do + :string.match?(/STRING/).should be_false + end - it "takes matching position as the 2nd argument" do - :string.match?(/str/i, 0).should be_true - :string.match?(/str/i, 1).should be_false - end + it "takes matching position as the 2nd argument" do + :string.match?(/str/i, 0).should be_true + :string.match?(/str/i, 1).should be_false end end diff --git a/spec/ruby/core/symbol/swapcase_spec.rb b/spec/ruby/core/symbol/swapcase_spec.rb index 9aec87a6d2..24709cac30 100644 --- a/spec/ruby/core/symbol/swapcase_spec.rb +++ b/spec/ruby/core/symbol/swapcase_spec.rb @@ -18,21 +18,9 @@ describe "Symbol#swapcase" do :mIxEd.swapcase.should == :MiXeD end - ruby_version_is ''...'2.4' do - it "leaves uppercase Unicode characters as they were" do - "\u{00DE}Bc".to_sym.swapcase.should == :"ÞbC" - end - - it "leaves lowercase Unicode characters as they were" do - "\u{00DF}Bc".to_sym.swapcase.should == :"ßbC" - end - end - - ruby_version_is '2.4' do - it "swaps the case for Unicode characters" do - "äÖü".to_sym.swapcase.should == :"ÄöÜ" - "aOu".to_sym.swapcase.should == :"AoU" - end + it "swaps the case for Unicode characters" do + "äÖü".to_sym.swapcase.should == :"ÄöÜ" + "aOu".to_sym.swapcase.should == :"AoU" end it "leaves non-alphabetic ASCII characters as they were" do diff --git a/spec/ruby/core/symbol/upcase_spec.rb b/spec/ruby/core/symbol/upcase_spec.rb index 6183f3b754..f704bdcbf3 100644 --- a/spec/ruby/core/symbol/upcase_spec.rb +++ b/spec/ruby/core/symbol/upcase_spec.rb @@ -10,17 +10,9 @@ describe "Symbol#upcase" do :lOwEr.upcase.should == :LOWER end - ruby_version_is ''...'2.4' do - it "leaves lowercase Unicode characters as they were" do - "\u{E0}Bc".to_sym.upcase.should == :"àBC" - end - end - - ruby_version_is '2.4' do - it "capitalizes all Unicode characters" do - "äöü".to_sym.upcase.should == :"ÄÖÜ" - "aou".to_sym.upcase.should == :"AOU" - end + it "capitalizes all Unicode characters" do + "äöü".to_sym.upcase.should == :"ÄÖÜ" + "aou".to_sym.upcase.should == :"AOU" end it "leaves non-alphabetic ASCII characters as they were" do diff --git a/spec/ruby/core/thread/report_on_exception_spec.rb b/spec/ruby/core/thread/report_on_exception_spec.rb index 16597f3a4b..a6042ba759 100644 --- a/spec/ruby/core/thread/report_on_exception_spec.rb +++ b/spec/ruby/core/thread/report_on_exception_spec.rb @@ -1,120 +1,116 @@ require_relative '../../spec_helper' -ruby_version_is "2.4" do - describe "Thread.report_on_exception" do - ruby_version_is "2.4"..."2.5" do - it "defaults to false" do - ruby_exe("p Thread.report_on_exception").should == "false\n" - end +describe "Thread.report_on_exception" do + ruby_version_is "2.4"..."2.5" do + it "defaults to false" do + ruby_exe("p Thread.report_on_exception").should == "false\n" end + end - ruby_version_is "2.5" do - it "defaults to true" do - ruby_exe("p Thread.report_on_exception").should == "true\n" - end + ruby_version_is "2.5" do + it "defaults to true" do + ruby_exe("p Thread.report_on_exception").should == "true\n" end end +end - describe "Thread.report_on_exception=" do - before :each do - @report_on_exception = Thread.report_on_exception - end +describe "Thread.report_on_exception=" do + before :each do + @report_on_exception = Thread.report_on_exception + end - after :each do - Thread.report_on_exception = @report_on_exception - end + after :each do + Thread.report_on_exception = @report_on_exception + end - it "changes the default value for new threads" do - Thread.report_on_exception = true - Thread.report_on_exception.should == true - t = Thread.new {} - t.join - t.report_on_exception.should == true - end + it "changes the default value for new threads" do + Thread.report_on_exception = true + Thread.report_on_exception.should == true + t = Thread.new {} + t.join + t.report_on_exception.should == true end +end - describe "Thread#report_on_exception" do - ruby_version_is "2.5" do - it "returns true for the main Thread" do - Thread.current.report_on_exception.should == true - end +describe "Thread#report_on_exception" do + ruby_version_is "2.5" do + it "returns true for the main Thread" do + Thread.current.report_on_exception.should == true + end - it "returns true for new Threads" do - Thread.new { Thread.current.report_on_exception }.value.should == true - end + it "returns true for new Threads" do + Thread.new { Thread.current.report_on_exception }.value.should == true end + end - it "returns whether the Thread will print a backtrace if it exits with an exception" do - t = Thread.new { Thread.current.report_on_exception = true } - t.join - t.report_on_exception.should == true + it "returns whether the Thread will print a backtrace if it exits with an exception" do + t = Thread.new { Thread.current.report_on_exception = true } + t.join + t.report_on_exception.should == true - t = Thread.new { Thread.current.report_on_exception = false } - t.join - t.report_on_exception.should == false - end + t = Thread.new { Thread.current.report_on_exception = false } + t.join + t.report_on_exception.should == false end +end - describe "Thread#report_on_exception=" do - describe "when set to true" do - it "prints a backtrace on $stderr if it terminates with an exception" do - t = nil - -> { - t = Thread.new { - Thread.current.report_on_exception = true - raise RuntimeError, "Thread#report_on_exception specs" - } - Thread.pass while t.alive? - }.should output("", /Thread.+terminated with exception.+Thread#report_on_exception specs/m) +describe "Thread#report_on_exception=" do + describe "when set to true" do + it "prints a backtrace on $stderr if it terminates with an exception" do + t = nil + -> { + t = Thread.new { + Thread.current.report_on_exception = true + raise RuntimeError, "Thread#report_on_exception specs" + } + Thread.pass while t.alive? + }.should output("", /Thread.+terminated with exception.+Thread#report_on_exception specs/m) + + -> { + t.join + }.should raise_error(RuntimeError, "Thread#report_on_exception specs") + end + end - -> { - t.join - }.should raise_error(RuntimeError, "Thread#report_on_exception specs") - end + describe "when set to false" do + it "lets the thread terminates silently with an exception" do + t = nil + -> { + t = Thread.new { + Thread.current.report_on_exception = false + raise RuntimeError, "Thread#report_on_exception specs" + } + Thread.pass while t.alive? + }.should output("", "") + + -> { + t.join + }.should raise_error(RuntimeError, "Thread#report_on_exception specs") end + end - describe "when set to false" do - it "lets the thread terminates silently with an exception" do - t = nil - -> { - t = Thread.new { - Thread.current.report_on_exception = false - raise RuntimeError, "Thread#report_on_exception specs" - } - Thread.pass while t.alive? - }.should output("", "") + describe "when used in conjunction with Thread#abort_on_exception" do + it "first reports then send the exception back to the main Thread" do + t = nil + mutex = Mutex.new + mutex.lock + -> { + t = Thread.new { + Thread.current.abort_on_exception = true + Thread.current.report_on_exception = true + mutex.lock + mutex.unlock + raise RuntimeError, "Thread#report_on_exception specs" + } -> { - t.join + mutex.sleep(5) }.should raise_error(RuntimeError, "Thread#report_on_exception specs") - end - end + }.should output("", /Thread.+terminated with exception.+Thread#report_on_exception specs/m) - ruby_bug "#13163", "2.4"..."2.5" do - describe "when used in conjunction with Thread#abort_on_exception" do - it "first reports then send the exception back to the main Thread" do - t = nil - mutex = Mutex.new - mutex.lock - -> { - t = Thread.new { - Thread.current.abort_on_exception = true - Thread.current.report_on_exception = true - mutex.lock - mutex.unlock - raise RuntimeError, "Thread#report_on_exception specs" - } - - -> { - mutex.sleep(5) - }.should raise_error(RuntimeError, "Thread#report_on_exception specs") - }.should output("", /Thread.+terminated with exception.+Thread#report_on_exception specs/m) - - -> { - t.join - }.should raise_error(RuntimeError, "Thread#report_on_exception specs") - end - end + -> { + t.join + }.should raise_error(RuntimeError, "Thread#report_on_exception specs") end end end diff --git a/spec/ruby/core/time/shared/now.rb b/spec/ruby/core/time/shared/now.rb index c548be283f..80f66a1134 100644 --- a/spec/ruby/core/time/shared/now.rb +++ b/spec/ruby/core/time/shared/now.rb @@ -8,7 +8,7 @@ describe :time_now, shared: true do it "sets the current time" do now = TimeSpecs::MethodHolder.send(@method) - now.to_f.should be_close(Process.clock_gettime(Process::CLOCK_REALTIME), 10.0) + now.to_f.should be_close(Process.clock_gettime(Process::CLOCK_REALTIME), TIME_TOLERANCE) end it "uses the local timezone" do @@ -17,4 +17,17 @@ describe :time_now, shared: true do now.utc_offset.should == (-8 * 60 * 60) end end + + it "has at least microsecond precision" do + times = [] + 10_000.times do + times << Time.now.nsec + end + + # The clock should not be less accurate than expected (times should + # not all be a multiple of the next precision up, assuming precisions + # are multiples of ten.) + expected = 1_000 + times.select { |t| t % (expected * 10) == 0 }.size.should_not == times.size + end end diff --git a/spec/ruby/core/tracepoint/callee_id_spec.rb b/spec/ruby/core/tracepoint/callee_id_spec.rb index 39a7413648..d340290d8b 100644 --- a/spec/ruby/core/tracepoint/callee_id_spec.rb +++ b/spec/ruby/core/tracepoint/callee_id_spec.rb @@ -1,19 +1,17 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -ruby_version_is '2.4' do - describe "TracePoint#callee_id" do - it "returns the called name of the method being called" do - a = [] - obj = TracePointSpec::ClassWithMethodAlias.new +describe "TracePoint#callee_id" do + it "returns the called name of the method being called" do + a = [] + obj = TracePointSpec::ClassWithMethodAlias.new - TracePoint.new(:call) do |tp| - a << tp.callee_id - end.enable do - obj.m_alias - end - - a.should == [:m_alias] + TracePoint.new(:call) do |tp| + a << tp.callee_id + end.enable do + obj.m_alias end + + a.should == [:m_alias] end end diff --git a/spec/ruby/core/tracepoint/disable_spec.rb b/spec/ruby/core/tracepoint/disable_spec.rb index 25d54502ab..612ca3c25a 100644 --- a/spec/ruby/core/tracepoint/disable_spec.rb +++ b/spec/ruby/core/tracepoint/disable_spec.rb @@ -58,18 +58,16 @@ describe 'TracePoint#disable' do end end - ruby_bug "#14057", ""..."2.5" do - it 'can accept param within a block but it should not yield arguments' do - trace = TracePoint.new(:line) {} - trace.enable - begin - trace.disable do |*args| - args.should == [] - end - trace.enabled?.should == true - ensure - trace.disable + it 'can accept param within a block but it should not yield arguments' do + trace = TracePoint.new(:line) {} + trace.enable + begin + trace.disable do |*args| + args.should == [] end + trace.enabled?.should == true + ensure + trace.disable end end end diff --git a/spec/ruby/core/tracepoint/enable_spec.rb b/spec/ruby/core/tracepoint/enable_spec.rb index 52c2248656..6eeec1d5db 100644 --- a/spec/ruby/core/tracepoint/enable_spec.rb +++ b/spec/ruby/core/tracepoint/enable_spec.rb @@ -58,16 +58,14 @@ describe 'TracePoint#enable' do end.enable { event_name.should equal(:line) } end - ruby_bug "#14057", ""..."2.5" do - it 'can accept arguments within a block but it should not yield arguments' do - event_name = nil - trace = TracePoint.new(:line) { |tp| event_name = tp.event } - trace.enable do |*args| - event_name.should equal(:line) - args.should == [] - end - trace.enabled?.should == false + it 'can accept arguments within a block but it should not yield arguments' do + event_name = nil + trace = TracePoint.new(:line) { |tp| event_name = tp.event } + trace.enable do |*args| + event_name.should equal(:line) + args.should == [] end + trace.enabled?.should == false end it 'enables trace object on calling with a block if it was already enabled' do @@ -193,7 +191,7 @@ describe 'TracePoint#enable' do end describe 'option value' do - it 'excepts Method' do + it 'accepts Method' do trace = TracePoint.new(:call) do |tp| ScratchPad << tp.method_id end @@ -208,7 +206,7 @@ describe 'TracePoint#enable' do ScratchPad.recorded.should == [:foo] end - it 'excepts UnboundMethod' do + it 'accepts UnboundMethod' do trace = TracePoint.new(:call) do |tp| ScratchPad << tp.method_id end @@ -225,7 +223,7 @@ describe 'TracePoint#enable' do ScratchPad.recorded.should == [:foo] end - it 'excepts Proc' do + it 'accepts Proc' do trace = TracePoint.new(:b_call) do |tp| ScratchPad << tp.lineno end @@ -240,36 +238,6 @@ describe 'TracePoint#enable' do ScratchPad.recorded.should == [lineno] lineno.should be_kind_of(Integer) end - - it 'excepts RubyVM::InstructionSequence' do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id - end - - obj = Object.new - def obj.foo; end - - iseq = RubyVM::InstructionSequence.of(obj.method(:foo)) - trace.enable(target: iseq) do - obj.foo - end - - ScratchPad.recorded.should == [:foo] - end - end - - it "raises ArgumentError when passed object isn't consisted of InstructionSequence (iseq)" do - trace = TracePoint.new(:call) do |tp| - ScratchPad << tp.method_id - end - - core_method = 'foo bar'.method(:bytes) - RubyVM::InstructionSequence.of(core_method).should == nil - - lambda { - trace.enable(target: core_method) do - end - }.should raise_error(ArgumentError, /specified target is not supported/) end it "raises ArgumentError if target object cannot trigger specified event" do @@ -286,7 +254,7 @@ describe 'TracePoint#enable' do }.should raise_error(ArgumentError, /can not enable any hooks/) end - it "raises ArgumentError if passed not Method/UnboundMethod/Proc/RubyVM::InstructionSequence" do + it "raises ArgumentError if passed not Method/UnboundMethod/Proc" do trace = TracePoint.new(:call) do |tp| end @@ -490,7 +458,7 @@ describe 'TracePoint#enable' do }.should raise_error(ArgumentError, /can not enable any hooks/) end - it "excepts value that could be coerced to Integer" do + it "accepts value that could be coerced to Integer" do trace = TracePoint.new(:line) do |tp| ScratchPad << tp.lineno end diff --git a/spec/ruby/core/tracepoint/instruction_sequence_spec.rb b/spec/ruby/core/tracepoint/instruction_sequence_spec.rb deleted file mode 100644 index 3e3b73cccc..0000000000 --- a/spec/ruby/core/tracepoint/instruction_sequence_spec.rb +++ /dev/null @@ -1,25 +0,0 @@ -require_relative '../../spec_helper' -require_relative 'fixtures/classes' - -ruby_version_is "2.6" do - describe "TracePoint#instruction_sequence" do - it "is an instruction sequence" do - ScratchPad.record [] - - script = <<-CODE - def foo - p :hello - end - CODE - - TracePoint.new(:script_compiled) do |e| - ScratchPad << e.instruction_sequence - end.enable do - eval script - end - - ScratchPad.recorded.size.should == 1 - ScratchPad.recorded[0].class.should == RubyVM::InstructionSequence - end - end -end diff --git a/spec/ruby/core/tracepoint/new_spec.rb b/spec/ruby/core/tracepoint/new_spec.rb index d333fd069a..916d826fdf 100644 --- a/spec/ruby/core/tracepoint/new_spec.rb +++ b/spec/ruby/core/tracepoint/new_spec.rb @@ -55,7 +55,7 @@ describe 'TracePoint.new' do -> { TracePoint.new(o) {}}.should raise_error(TypeError) end - ruby_bug "#140740", ""..."2.5" do + ruby_version_is "2.5" do it 'expects to be called with a block' do -> { TracePoint.new(:line) }.should raise_error(ArgumentError, "must be called with a block") end diff --git a/spec/ruby/core/true/dup_spec.rb b/spec/ruby/core/true/dup_spec.rb index 369910ab2c..351457ed22 100644 --- a/spec/ruby/core/true/dup_spec.rb +++ b/spec/ruby/core/true/dup_spec.rb @@ -1,9 +1,7 @@ require_relative '../../spec_helper' -ruby_version_is '2.4' do - describe "TrueClass#dup" do - it "returns self" do - true.dup.should equal(true) - end +describe "TrueClass#dup" do + it "returns self" do + true.dup.should equal(true) end end diff --git a/spec/ruby/core/warning/warn_spec.rb b/spec/ruby/core/warning/warn_spec.rb index 2844d97e76..7daf6323c3 100644 --- a/spec/ruby/core/warning/warn_spec.rb +++ b/spec/ruby/core/warning/warn_spec.rb @@ -1,61 +1,59 @@ require_relative '../../spec_helper' describe "Warning.warn" do - ruby_version_is "2.4" do - it "complains" do - -> { - Warning.warn("Chunky bacon!") - }.should complain("Chunky bacon!") - end + it "complains" do + -> { + Warning.warn("Chunky bacon!") + }.should complain("Chunky bacon!") + end - it "does not add a newline" do - ruby_exe("Warning.warn('test')", args: "2>&1").should == "test" - end + it "does not add a newline" do + ruby_exe("Warning.warn('test')", args: "2>&1").should == "test" + end - it "returns nil" do - ruby_exe("p Warning.warn('test')", args: "2>&1").should == "testnil\n" - end + it "returns nil" do + ruby_exe("p Warning.warn('test')", args: "2>&1").should == "testnil\n" + end - it "extends itself" do - Warning.singleton_class.ancestors.should include(Warning) - end + it "extends itself" do + Warning.singleton_class.ancestors.should include(Warning) + end - it "has Warning as the method owner" do - ruby_exe("p Warning.method(:warn).owner").should == "Warning\n" - end + it "has Warning as the method owner" do + ruby_exe("p Warning.method(:warn).owner").should == "Warning\n" + end - it "can be overridden" do - code = <<-RUBY - $stdout.sync = true - $stderr.sync = true - def Warning.warn(msg) - if msg.start_with?("A") - puts msg.upcase - else - super - end + it "can be overridden" do + code = <<-RUBY + $stdout.sync = true + $stderr.sync = true + def Warning.warn(msg) + if msg.start_with?("A") + puts msg.upcase + else + super end - Warning.warn("A warning!") - Warning.warn("warning from stderr\n") - RUBY - ruby_exe(code, args: "2>&1").should == %Q[A WARNING!\nwarning from stderr\n] - end - - it "is called by parser warnings" do - Warning.should_receive(:warn) - verbose = $VERBOSE - $VERBOSE = false - begin - eval "{ key: :value, key: :value2 }" - ensure - $VERBOSE = verbose end + Warning.warn("A warning!") + Warning.warn("warning from stderr\n") + RUBY + ruby_exe(code, args: "2>&1").should == %Q[A WARNING!\nwarning from stderr\n] + end + + it "is called by parser warnings" do + Warning.should_receive(:warn) + verbose = $VERBOSE + $VERBOSE = false + begin + eval "{ key: :value, key: :value2 }" + ensure + $VERBOSE = verbose end end ruby_version_is "2.5" do it "is called by Kernel.warn" do - Warning.should_receive(:warn) + Warning.should_receive(:warn).with("Chunky bacon!\n") verbose = $VERBOSE $VERBOSE = false begin |