kotovalexarian-likes-github/ruby--ruby
1
0
Fork 0
mirror of https://github.com/ruby/ruby.git synced 2022-11-09 12:17:21 -05:00
Code Releases Activity

Update to ruby/spec@3affe1e

Browse source
This commit is contained in:
Benoit Daloze 2022-04-25 14:53:54 +02:00
parent 6ae81d49b5
commit 45cf4f2187
277 changed files with 3844 additions and 7624 deletions
Download patch file Download diff file Expand all files Collapse all files

45
spec/ruby/.rubocop.yml
View file

@ -1,11 +1,12 @@
inherit_from: .rubocop_todo.yml
AllCops:
TargetRubyVersion: 2.6
TargetRubyVersion: 2.7
DisplayCopNames: true
Exclude:
- command_line/fixtures/bad_syntax.rb
DisabledByDefault: true
NewCops: disable
Layout/TrailingWhitespace:
Enabled: true
@ -56,12 +57,52 @@ Lint/UnusedMethodArgument:
Lint/UselessAssignment:
Enabled: false
Lint/UselessComparison:
Lint/BinaryOperatorWithIdenticalOperands:
Enabled: false
Lint/EmptyConditionalBody:
Enabled: false # buggy
Lint/Void:
Enabled: false
Lint/ConstantDefinitionInBlock:
Enabled: false
Lint/RaiseException:
Enabled: false
Lint/FloatComparison:
Enabled: false
Lint/DeprecatedClassMethods:
Enabled: false
Lint/UnreachableLoop:
Enabled: false
Lint/MissingSuper:
Enabled: false
Lint/UselessMethodDefinition:
Enabled: false
Lint/UselessTimes:
Enabled: false
Lint/MixedRegexpCaptureTypes:
Enabled: false
Lint/DuplicateElsifCondition:
Enabled: false
Lint/OutOfRangeRegexpRef:
Enabled: false
Lint/ElseLayout:
Exclude:
- 'language/if_spec.rb'
Lint/EmptyExpression:
Exclude:
- 'language/**/*.rb'

2
spec/ruby/CONTRIBUTING.md
View file

@ -180,7 +180,7 @@ First, file a bug at https://bugs.ruby-lang.org/.
It is better to use a `ruby_version_is` guard if there was a release with the fix.
```ruby
ruby_bug '#13669', ''...'2.7' do
ruby_bug '#13669', ''...'3.2' do
it "works like this" do
# Specify the expected behavior here, not the bug
end

5
spec/ruby/README.md
View file

@ -31,8 +31,8 @@ ruby/spec is known to be tested in these implementations for every commit:
* [Opal](https://github.com/opal/opal/tree/master/spec)
* [Artichoke](https://github.com/artichoke/spec/tree/artichoke-vendor)
ruby/spec describes the behavior of Ruby 2.6 and more recent Ruby versions.
More precisely, every latest stable MRI release should [pass](https://github.com/ruby/spec/actions/workflows/ci.yml) all specs of ruby/spec (2.6.x, 2.7.x, 3.0.x, etc), and those are tested in CI.
ruby/spec describes the behavior of Ruby 2.7 and more recent Ruby versions.
More precisely, every latest stable MRI release should [pass](https://github.com/ruby/spec/actions/workflows/ci.yml) all specs of ruby/spec (2.7.x, 3.0.x, 3.1.x, etc), and those are tested in CI.
### Synchronization with Ruby Implementations
@ -61,6 +61,7 @@ For older specs try these commits:
* Ruby 2.3.8 - [Suite](https://github.com/ruby/spec/commit/dc733114d8ae66a3368ba3a98422c50147a76ba5) using [MSpec](https://github.com/ruby/mspec/commit/4599bc195fb109f2a482a01c32a7d659518369ea)
* Ruby 2.4.10 - [Suite](https://github.com/ruby/spec/commit/bce4f2b81d6c31db67cf4d023a0625ceadde59bd) using [MSpec](https://github.com/ruby/mspec/commit/e7eb8aa4c26495b7b461e687d950b96eb08b3ff2)
* Ruby 2.5.9 - [Suite](https://github.com/ruby/spec/commit/c503335d3d9f6ec6ef24de60a0716c34af69b64f) using [MSpec](https://github.com/ruby/mspec/commit/0091e8a62e954717cd54641f935eaf1403692041)
* Ruby 2.6.10 - [Suite](https://github.com/ruby/spec/commit/aaf998fb8c92c4e63ad423a2e7ca6e6921818c6e) using [MSpec](https://github.com/ruby/mspec/commit/5e36c684e9e2b92b1187589bba1df22c640a8661)
### Running the specs

17
spec/ruby/command_line/dash_upper_w_spec.rb
View file

@ -19,29 +19,26 @@ describe "The -W command line option with 2" do
it_behaves_like :command_line_verbose, "-W2"
end
# Regarding the defaults, see core/warning/element_reference_spec.rb
ruby_version_is "2.7" do
describe "The -W command line option with :deprecated" do
describe "The -W command line option with :deprecated" do
it "enables deprecation warnings" do
ruby_exe('p Warning[:deprecated]', options: '-W:deprecated').should == "true\n"
end
end
end
describe "The -W command line option with :no-deprecated" do
describe "The -W command line option with :no-deprecated" do
it "suppresses deprecation warnings" do
ruby_exe('p Warning[:deprecated]', options: '-w -W:no-deprecated').should == "false\n"
end
end
end
describe "The -W command line option with :experimental" do
describe "The -W command line option with :experimental" do
it "enables experimental warnings" do
ruby_exe('p Warning[:experimental]', options: '-W:experimental').should == "true\n"
end
end
end
describe "The -W command line option with :no-experimental" do
describe "The -W command line option with :no-experimental" do
it "suppresses experimental warnings" do
ruby_exe('p Warning[:experimental]', options: '-w -W:no-experimental').should == "false\n"
end
end
end

2
spec/ruby/command_line/dash_w_spec.rb
View file

@ -4,9 +4,7 @@ require_relative 'shared/verbose'
describe "The -w command line option" do
it_behaves_like :command_line_verbose, "-w"
ruby_version_is "2.7" do
it "enables both deprecated and experimental warnings" do
ruby_exe('p Warning[:deprecated]; p Warning[:experimental]', options: '-w').should == "true\ntrue\n"
end
end
end

2
spec/ruby/command_line/fixtures/freeze_flag_two_literals.rb
View file

@ -1 +1 @@
p "abc".object_id == "abc".object_id
p "abc".equal?("abc")

2
spec/ruby/command_line/rubyopt_spec.rb
View file

@ -59,7 +59,6 @@ describe "Processing RUBYOPT" do
ruby_exe("p $VERBOSE", escape: true).chomp.should == "true"
end
ruby_version_is "2.7" do
it "suppresses deprecation warnings for '-W:no-deprecated'" do
ENV["RUBYOPT"] = '-W:no-deprecated'
result = ruby_exe('$; = ""', args: '2>&1')
@ -77,7 +76,6 @@ describe "Processing RUBYOPT" do
result = ruby_exe('case ($; = ""); in a; end', args: '2>&1')
result.should == ""
end
end
it "requires the file for '-r'" do
f = fixture __FILE__, "rubyopt"

20
spec/ruby/core/array/clear_spec.rb
View file

@ -20,30 +20,10 @@ describe "Array#clear" do
a.size.should == 0
end
ruby_version_is ''...'2.7' do
it "keeps tainted status" do
a = [1]
a.taint
a.tainted?.should be_true
a.clear
a.tainted?.should be_true
end
end
it "does not accept any arguments" do
-> { [1].clear(true) }.should raise_error(ArgumentError)
end
ruby_version_is ''...'2.7' do
it "keeps untrusted status" do
a = [1]
a.untrust
a.untrusted?.should be_true
a.clear
a.untrusted?.should be_true
end
end
it "raises a FrozenError on a frozen array" do
a = [1]
a.freeze

30
spec/ruby/core/array/compact_spec.rb
View file

@ -21,20 +21,6 @@ describe "Array#compact" do
it "does not return subclass instance for Array subclasses" do
ArraySpecs::MyArray[1, 2, 3, nil].compact.should be_an_instance_of(Array)
end
ruby_version_is ''...'2.7' do
it "does not keep tainted status even if all elements are removed" do
a = [nil, nil]
a.taint
a.compact.tainted?.should be_false
end
it "does not keep untrusted status even if all elements are removed" do
a = [nil, nil]
a.untrust
a.compact.untrusted?.should be_false
end
end
end
describe "Array#compact!" do
@ -59,22 +45,6 @@ describe "Array#compact!" do
[1, 2, false, 3].compact!.should == nil
end
ruby_version_is ''...'2.7' do
it "keeps tainted status even if all elements are removed" do
a = [nil, nil]
a.taint
a.compact!
a.tainted?.should be_true
end
it "keeps untrusted status even if all elements are removed" do
a = [nil, nil]
a.untrust
a.compact!
a.untrusted?.should be_true
end
end
it "raises a FrozenError on a frozen array" do
-> { ArraySpecs.frozen_array.compact! }.should raise_error(FrozenError)
end

58
spec/ruby/core/array/concat_spec.rb
View file

@ -41,64 +41,6 @@ describe "Array#concat" do
-> { ArraySpecs.frozen_array.concat([]) }.should raise_error(FrozenError)
end
ruby_version_is ''...'2.7' do
it "keeps tainted status" do
ary = [1, 2]
ary.taint
ary.concat([3])
ary.tainted?.should be_true
ary.concat([])
ary.tainted?.should be_true
end
it "is not infected by the other" do
ary = [1,2]
other = [3]; other.taint
ary.tainted?.should be_false
ary.concat(other)
ary.tainted?.should be_false
end
it "keeps the tainted status of elements" do
ary = [ Object.new, Object.new, Object.new ]
ary.each {|x| x.taint }
ary.concat([ Object.new ])
ary[0].tainted?.should be_true
ary[1].tainted?.should be_true
ary[2].tainted?.should be_true
ary[3].tainted?.should be_false
end
it "keeps untrusted status" do
ary = [1, 2]
ary.untrust
ary.concat([3])
ary.untrusted?.should be_true
ary.concat([])
ary.untrusted?.should be_true
end
it "is not infected untrustedness by the other" do
ary = [1,2]
other = [3]; other.untrust
ary.untrusted?.should be_false
ary.concat(other)
ary.untrusted?.should be_false
end
it "keeps the untrusted status of elements" do
ary = [ Object.new, Object.new, Object.new ]
ary.each {|x| x.untrust }
ary.concat([ Object.new ])
ary[0].untrusted?.should be_true
ary[1].untrusted?.should be_true
ary[2].untrusted?.should be_true
ary[3].untrusted?.should be_false
end
end
it "appends elements to an Array with enough capacity that has been shifted" do
ary = [1, 2, 3, 4, 5]
2.times { ary.shift }

4
spec/ruby/core/array/deconstruct_spec.rb
View file

@ -1,11 +1,9 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" do
describe "Array#deconstruct" do
describe "Array#deconstruct" do
it "returns self" do
array = [1]
array.deconstruct.should equal array
end
end
end

22
spec/ruby/core/array/delete_at_spec.rb
View file

@ -38,26 +38,4 @@ describe "Array#delete_at" do
it "raises a FrozenError on a frozen array" do
-> { [1,2,3].freeze.delete_at(0) }.should raise_error(FrozenError)
end
ruby_version_is ''...'2.7' do
it "keeps tainted status" do
ary = [1, 2]
ary.taint
ary.tainted?.should be_true
ary.delete_at(0)
ary.tainted?.should be_true
ary.delete_at(0) # now empty
ary.tainted?.should be_true
end
it "keeps untrusted status" do
ary = [1, 2]
ary.untrust
ary.untrusted?.should be_true
ary.delete_at(0)
ary.untrusted?.should be_true
ary.delete_at(0) # now empty
ary.untrusted?.should be_true
end
end
end

16
spec/ruby/core/array/delete_if_spec.rb
View file

@ -47,22 +47,6 @@ describe "Array#delete_if" do
-> { ArraySpecs.empty_frozen_array.delete_if {} }.should raise_error(FrozenError)
end
ruby_version_is ''...'2.7' do
it "keeps tainted status" do
@a.taint
@a.tainted?.should be_true
@a.delete_if{ true }
@a.tainted?.should be_true
end
it "keeps untrusted status" do
@a.untrust
@a.untrusted?.should be_true
@a.delete_if{ true }
@a.untrusted?.should be_true
end
end
it_behaves_like :enumeratorized_with_origin_size, :delete_if, [1,2,3]
it_behaves_like :delete_if, :delete_if
end

22
spec/ruby/core/array/delete_spec.rb
View file

@ -43,26 +43,4 @@ describe "Array#delete" do
it "raises a FrozenError on a frozen array" do
-> { [1, 2, 3].freeze.delete(1) }.should raise_error(FrozenError)
end
ruby_version_is ''...'2.7' do
it "keeps tainted status" do
a = [1, 2]
a.taint
a.tainted?.should be_true
a.delete(2)
a.tainted?.should be_true
a.delete(1) # now empty
a.tainted?.should be_true
end
it "keeps untrusted status" do
a = [1, 2]
a.untrust
a.untrusted?.should be_true
a.delete(2)
a.untrusted?.should be_true
a.delete(1) # now empty
a.untrusted?.should be_true
end
end
end

24
spec/ruby/core/array/element_set_spec.rb
View file

@ -481,51 +481,49 @@ describe "Array#[]= with [m..]" do
end
end
ruby_version_is "2.7" do
describe "Array#[]= with [..n] and [...n]" do
describe "Array#[]= with [..n] and [...n]" do
it "just sets the section defined by range to nil even if the rhs is nil" do
a = [1, 2, 3, 4, 5]
a[eval("(..2)")] = nil
a[(..2)] = nil
a.should == [nil, 4, 5]
a[eval("(...2)")] = nil
a[(...2)] = nil
a.should == [nil, 5]
end
it "just sets the section defined by range to nil if n < 0 and the rhs is nil" do
a = [1, 2, 3, 4, 5]
a[eval("(..-3)")] = nil
a[(..-3)] = nil
a.should == [nil, 4, 5]
a[eval("(...-1)")] = [nil, 5]
a[(...-1)] = [nil, 5]
end
it "replaces the section defined by range" do
a = [6, 5, 4, 3, 2, 1]
a[eval("(...3)")] = 9
a[(...3)] = 9
a.should == [9, 3, 2, 1]
a[eval("(..2)")] = [7, 7, 7, 7, 7]
a[(..2)] = [7, 7, 7, 7, 7]
a.should == [7, 7, 7, 7, 7, 1]
end
it "replaces the section if n < 0" do
a = [1, 2, 3, 4, 5]
a[eval("(..-2)")] = [7, 8, 9]
a[(..-2)] = [7, 8, 9]
a.should == [7, 8, 9, 5]
end
it "replaces everything if n > the array size" do
a = [1, 2, 3]
a[eval("(...7)")] = [4]
a[(...7)] = [4]
a.should == [4]
end
it "inserts at the beginning if n < negative the array size" do
a = [1, 2, 3]
a[eval("(..-7)")] = [4]
a[(..-7)] = [4]
a.should == [4, 1, 2, 3]
a[eval("(...-10)")] = [6]
a[(...-10)] = [6]
a.should == [6, 4, 1, 2, 3]
end
end
end
describe "Array#[] after a shift" do

6
spec/ruby/core/array/fill_spec.rb
View file

@ -323,10 +323,8 @@ describe "Array#fill with (filler, range)" do
[1, 2, 3, 4].fill(eval("(3...)")) { |x| x + 2 }.should == [1, 2, 3, 5]
end
ruby_version_is "2.7" do
it "works with beginless ranges" do
[1, 2, 3, 4].fill('x', eval("(..2)")).should == ["x", "x", "x", 4]
[1, 2, 3, 4].fill(eval("(...2)")) { |x| x + 2 }.should == [2, 3, 3, 4]
end
[1, 2, 3, 4].fill('x', (..2)).should == ["x", "x", "x", 4]
[1, 2, 3, 4].fill((...2)) { |x| x + 2 }.should == [2, 3, 3, 4]
end
end

10
spec/ruby/core/array/flatten_spec.rb
View file

@ -147,16 +147,6 @@ describe "Array#flatten" do
end
end
ruby_version_is ''...'2.7' do
it "returns a tainted array if self is tainted" do
[].taint.flatten.tainted?.should be_true
end
it "returns an untrusted array if self is untrusted" do
[].untrust.flatten.untrusted?.should be_true
end
end
it "performs respond_to? and method_missing-aware checks when coercing elements to array" do
bo = BasicObject.new
[bo].flatten.should == [bo]

4
spec/ruby/core/array/intersection_spec.rb
View file

@ -6,8 +6,7 @@ describe "Array#&" do
it_behaves_like :array_intersection, :&
end
ruby_version_is "2.7" do
describe "Array#intersection" do
describe "Array#intersection" do
it_behaves_like :array_intersection, :intersection
it "accepts multiple arguments" do
@ -17,5 +16,4 @@ ruby_version_is "2.7" do
it "preserves elements order from original array" do
[1, 2, 3, 4].intersection([3, 2, 1]).should == [1, 2, 3]
end
end
end

40
spec/ruby/core/array/multiply_spec.rb
View file

@ -97,46 +97,6 @@ describe "Array#* with an integer" do
ScratchPad.recorded.should be_nil
end
end
ruby_version_is ''...'2.7' do
it "copies the taint status of the original array even if the passed count is 0" do
ary = [1, 2, 3]
ary.taint
(ary * 0).should.tainted?
end
it "copies the taint status of the original array even if the array is empty" do
ary = []
ary.taint
(ary * 3).should.tainted?
end
it "copies the taint status of the original array if the passed count is not 0" do
ary = [1, 2, 3]
ary.taint
(ary * 1).should.tainted?
(ary * 2).should.tainted?
end
it "copies the untrusted status of the original array even if the passed count is 0" do
ary = [1, 2, 3]
ary.untrust
(ary * 0).should.untrusted?
end
it "copies the untrusted status of the original array even if the array is empty" do
ary = []
ary.untrust
(ary * 3).should.untrusted?
end
it "copies the untrusted status of the original array if the passed count is not 0" do
ary = [1, 2, 3]
ary.untrust
(ary * 1).should.untrusted?
(ary * 2).should.untrusted?
end
end
end
describe "Array#* with a string" do

24
spec/ruby/core/array/pack/p_spec.rb
View file

@ -15,18 +15,6 @@ describe "Array#pack with format 'P'" do
["hello"].pack("P").unpack("P5").should == ["hello"]
end
ruby_version_is ''...'2.7' do
it "taints the input string" do
input_string = "hello"
[input_string].pack("P")
input_string.tainted?.should be_true
end
it "does not taint the output string in normal cases" do
["hello"].pack("P").tainted?.should be_false
end
end
it "with nil gives a null pointer" do
[nil].pack("P").unpack("J").should == [0]
end
@ -44,18 +32,6 @@ describe "Array#pack with format 'p'" do
["hello"].pack("p").unpack("p").should == ["hello"]
end
ruby_version_is ''...'2.7' do
it "taints the input string" do
input_string = "hello"
[input_string].pack("p")
input_string.tainted?.should be_true
end
it "does not taint the output string in normal cases" do
["hello"].pack("p").tainted?.should be_false
end
end
it "with nil gives a null pointer" do
[nil].pack("p").unpack("J").should == [0]
end

12
spec/ruby/core/array/pack/shared/basic.rb
View file

@ -32,12 +32,6 @@ describe :array_pack_basic_non_float, shared: true do
d.should_receive(:to_str).and_return("x"+pack_format)
[@obj, @obj].pack(d).should be_an_instance_of(String)
end
ruby_version_is ''...'2.7' do
it "taints the output string if the format string is tainted" do
[@obj, @obj].pack("x"+pack_format.taint).tainted?.should be_true
end
end
end
describe :array_pack_basic_float, shared: true do
@ -50,12 +44,6 @@ describe :array_pack_basic_float, shared: true do
d.should_receive(:to_str).and_return("x"+pack_format)
[1.2, 4.7].pack(d).should be_an_instance_of(String)
end
ruby_version_is ''...'2.7' do
it "taints the output string if the format string is tainted" do
[3.2, 2.8].pack("x"+pack_format.taint).tainted?.should be_true
end
end
end
describe :array_pack_no_platform, shared: true do

33
spec/ruby/core/array/pack/shared/taint.rb
View file

@ -1,35 +1,2 @@
describe :array_pack_taint, shared: true do
ruby_version_is ''...'2.7' do
it "returns a tainted string when a pack argument is tainted" do
["abcd".taint, 0x20].pack(pack_format("3C")).tainted?.should be_true
end
it "does not return a tainted string when the array is tainted" do
["abcd", 0x20].taint.pack(pack_format("3C")).tainted?.should be_false
end
it "returns a tainted string when the format is tainted" do
["abcd", 0x20].pack(pack_format("3C").taint).tainted?.should be_true
end
it "returns a tainted string when an empty format is tainted" do
["abcd", 0x20].pack("".taint).tainted?.should be_true
end
it "returns a untrusted string when the format is untrusted" do
["abcd", 0x20].pack(pack_format("3C").untrust).untrusted?.should be_true
end
it "returns a untrusted string when the empty format is untrusted" do
["abcd", 0x20].pack("".untrust).untrusted?.should be_true
end
it "returns a untrusted string when a pack argument is untrusted" do
["abcd".untrust, 0x20].pack(pack_format("3C")).untrusted?.should be_true
end
it "returns a trusted string when the array is untrusted" do
["abcd", 0x20].untrust.pack(pack_format("3C")).untrusted?.should be_false
end
end
end

16
spec/ruby/core/array/plus_spec.rb
View file

@ -40,20 +40,4 @@ describe "Array#+" do
it "does not call to_ary on array subclasses" do
([5, 6] + ArraySpecs::ToAryArray[1, 2]).should == [5, 6, 1, 2]
end
ruby_version_is ''...'2.7' do
it "does not get infected even if an original array is tainted" do
([1, 2] + [3, 4]).tainted?.should be_false
([1, 2].taint + [3, 4]).tainted?.should be_false
([1, 2] + [3, 4].taint).tainted?.should be_false
([1, 2].taint + [3, 4].taint).tainted?.should be_false
end
it "does not infected even if an original array is untrusted" do
([1, 2] + [3, 4]).untrusted?.should be_false
([1, 2].untrust + [3, 4]).untrusted?.should be_false
([1, 2] + [3, 4].untrust).untrusted?.should be_false
([1, 2].untrust + [3, 4].untrust).untrusted?.should be_false
end
end
end

52
spec/ruby/core/array/pop_spec.rb
View file

@ -30,16 +30,6 @@ describe "Array#pop" do
array.pop.should == [1, 'two', 3.0, array, array, array, array]
end
ruby_version_is ''...'2.7' do
it "keeps taint status" do
a = [1, 2].taint
a.pop
a.tainted?.should be_true
a.pop
a.tainted?.should be_true
end
end
it "raises a FrozenError on a frozen array" do
-> { ArraySpecs.frozen_array.pop }.should raise_error(FrozenError)
end
@ -48,16 +38,6 @@ describe "Array#pop" do
-> { ArraySpecs.empty_frozen_array.pop }.should raise_error(FrozenError)
end
ruby_version_is ''...'2.7' do
it "keeps untrusted status" do
a = [1, 2].untrust
a.pop
a.untrusted?.should be_true
a.pop
a.untrusted?.should be_true
end
end
describe "passed a number n as an argument" do
it "removes and returns an array with the last n elements of the array" do
a = [1, 2, 3, 4, 5, 6]
@ -136,41 +116,9 @@ describe "Array#pop" do
ArraySpecs::MyArray[1, 2, 3].pop(2).should be_an_instance_of(Array)
end
ruby_version_is ''...'2.7' do
it "returns an untainted array even if the array is tainted" do
ary = [1, 2].taint
ary.pop(2).tainted?.should be_false
ary.pop(0).tainted?.should be_false
end
it "keeps taint status" do
a = [1, 2].taint
a.pop(2)
a.tainted?.should be_true
a.pop(2)
a.tainted?.should be_true
end
it "returns a trusted array even if the array is untrusted" do
ary = [1, 2].untrust
ary.pop(2).untrusted?.should be_false
ary.pop(0).untrusted?.should be_false
end
end
it "raises a FrozenError on a frozen array" do
-> { ArraySpecs.frozen_array.pop(2) }.should raise_error(FrozenError)
-> { ArraySpecs.frozen_array.pop(0) }.should raise_error(FrozenError)
end
ruby_version_is ''...'2.7' do
it "keeps untrusted status" do
a = [1, 2].untrust
a.pop(2)
a.untrusted?.should be_true
a.pop(2)
a.untrusted?.should be_true
end
end
end
end

24
spec/ruby/core/array/shared/clone.rb
View file

@ -17,28 +17,4 @@ describe :array_clone, shared: true do
b.should == a
b.__id__.should_not == a.__id__
end
ruby_version_is ''...'2.7' do
it "copies taint status from the original" do
a = [1, 2, 3, 4]
b = [1, 2, 3, 4]
a.taint
aa = a.send @method
bb = b.send @method
aa.should.tainted?
bb.should_not.tainted?
end
it "copies untrusted status from the original" do
a = [1, 2, 3, 4]
b = [1, 2, 3, 4]
a.untrust
aa = a.send @method
bb = b.send @method
aa.should.untrusted?
bb.should_not.untrusted?
end
end
end

31
spec/ruby/core/array/shared/collect.rb
View file

@ -42,20 +42,6 @@ describe :array_collect, shared: true do
}.should raise_error(ArgumentError)
end
ruby_version_is ''...'2.7' do
it "does not copy tainted status" do
a = [1, 2, 3]
a.taint
a.send(@method){|x| x}.tainted?.should be_false
end
it "does not copy untrusted status" do
a = [1, 2, 3]
a.untrust
a.send(@method){|x| x}.untrusted?.should be_false
end
end
before :all do
@object = [1, 2, 3, 4]
end
@ -96,23 +82,6 @@ describe :array_collect_b, shared: true do
a.should == ["1!", "2!", "3!"]
end
ruby_version_is ''...'2.7' do
it "keeps tainted status" do
a = [1, 2, 3]
a.taint
a.tainted?.should be_true
a.send(@method){|x| x}
a.tainted?.should be_true
end
it "keeps untrusted status" do
a = [1, 2, 3]
a.untrust
a.send(@method){|x| x}
a.untrusted?.should be_true
end
end
describe "when frozen" do
it "raises a FrozenError" do
-> { ArraySpecs.frozen_array.send(@method) {} }.should raise_error(FrozenError)

26
spec/ruby/core/array/shared/inspect.rb
View file

@ -64,32 +64,6 @@ describe :array_inspect, shared: true do
ArraySpecs.empty_recursive_array.send(@method).should == "[[...]]"
end
ruby_version_is ''...'2.7' do
it "taints the result if the Array is non-empty and tainted" do
[1, 2].taint.send(@method).tainted?.should be_true
end
it "does not taint the result if the Array is tainted but empty" do
[].taint.send(@method).tainted?.should be_false
end
it "taints the result if an element is tainted" do
["str".taint].send(@method).tainted?.should be_true
end
it "untrusts the result if the Array is untrusted" do
[1, 2].untrust.send(@method).untrusted?.should be_true
end
it "does not untrust the result if the Array is untrusted but empty" do
[].untrust.send(@method).untrusted?.should be_false
end
it "untrusts the result if an element is untrusted" do
["str".untrust].send(@method).untrusted?.should be_true
end
end
describe "with encoding" do
before :each do
@default_external_encoding = Encoding.default_external

70
spec/ruby/core/array/shared/join.rb
View file

@ -58,36 +58,6 @@ describe :array_join_with_default_separator, shared: true do
-> { ArraySpecs.empty_recursive_array.send(@method) }.should raise_error(ArgumentError)
end
ruby_version_is ''...'2.7' do
it "taints the result if the Array is tainted and non-empty" do
[1, 2].taint.send(@method).tainted?.should be_true
end
it "does not taint the result if the Array is tainted but empty" do
[].taint.send(@method).tainted?.should be_false
end
it "taints the result if the result of coercing an element is tainted" do
s = mock("taint")
s.should_receive(:to_s).and_return("str".taint)
[s].send(@method).tainted?.should be_true
end
it "untrusts the result if the Array is untrusted and non-empty" do
[1, 2].untrust.send(@method).untrusted?.should be_true
end
it "does not untrust the result if the Array is untrusted but empty" do
[].untrust.send(@method).untrusted?.should be_false
end
it "untrusts the result if the result of coercing an element is untrusted" do
s = mock("untrust")
s.should_receive(:to_s).and_return("str".untrust)
[s].send(@method).untrusted?.should be_true
end
end
it "uses the first encoding when other strings are compatible" do
ary1 = ArraySpecs.array_with_7bit_utf8_and_usascii_strings
ary2 = ArraySpecs.array_with_usascii_and_7bit_utf8_strings
@ -114,7 +84,6 @@ describe :array_join_with_default_separator, shared: true do
-> { ary_utf8_bad_binary.send(@method) }.should raise_error(EncodingError)
end
ruby_version_is "2.7" do
context "when $, is not nil" do
before do
suppress_warning do
@ -127,7 +96,6 @@ describe :array_join_with_default_separator, shared: true do
-> { [].join(nil) }.should complain(/warning: \$, is set to non-nil value/)
end
end
end
end
describe :array_join_with_string_separator, shared: true do
@ -141,42 +109,4 @@ describe :array_join_with_string_separator, shared: true do
[1, [2, [3, 4], 5], 6].send(@method, ":").should == "1:2:3:4:5:6"
[1, [2, ArraySpecs::MyArray[3, 4], 5], 6].send(@method, ":").should == "1:2:3:4:5:6"
end
ruby_version_is ''...'2.7' do
describe "with a tainted separator" do
before :each do
@sep = ":".taint
end
it "does not taint the result if the array is empty" do
[].send(@method, @sep).tainted?.should be_false
end
it "does not taint the result if the array has only one element" do
[1].send(@method, @sep).tainted?.should be_false
end
it "taints the result if the array has two or more elements" do
[1, 2].send(@method, @sep).tainted?.should be_true
end
end
describe "with an untrusted separator" do
before :each do
@sep = ":".untrust
end
it "does not untrust the result if the array is empty" do
[].send(@method, @sep).untrusted?.should be_false
end
it "does not untrust the result if the array has only one element" do
[1].send(@method, @sep).untrusted?.should be_false
end
it "untrusts the result if the array has two or more elements" do
[1, 2].send(@method, @sep).untrusted?.should be_true
end
end
end
end

60
spec/ruby/core/array/shared/slice.rb
View file

@ -556,34 +556,34 @@ describe :array_slice, shared: true do
it "has beginless range and positive steps" do
# end with zero index
@array.send(@method, eval("(..0).step(1)")).should == [0]
@array.send(@method, eval("(...0).step(1)")).should == []
@array.send(@method, (..0).step(1)).should == [0]
@array.send(@method, (...0).step(1)).should == []
@array.send(@method, eval("(..0).step(2)")).should == [0]
@array.send(@method, eval("(...0).step(2)")).should == []
@array.send(@method, (..0).step(2)).should == [0]
@array.send(@method, (...0).step(2)).should == []
@array.send(@method, eval("(..0).step(10)")).should == [0]
@array.send(@method, eval("(...0).step(10)")).should == []
@array.send(@method, (..0).step(10)).should == [0]
@array.send(@method, (...0).step(10)).should == []
# end with positive index
@array.send(@method, eval("(..3).step(1)")).should == [0, 1, 2, 3]
@array.send(@method, eval("(...3).step(1)")).should == [0, 1, 2]
@array.send(@method, (..3).step(1)).should == [0, 1, 2, 3]
@array.send(@method, (...3).step(1)).should == [0, 1, 2]
@array.send(@method, eval("(..3).step(2)")).should == [0, 2]
@array.send(@method, eval("(...3).step(2)")).should == [0, 2]
@array.send(@method, (..3).step(2)).should == [0, 2]
@array.send(@method, (...3).step(2)).should == [0, 2]
@array.send(@method, eval("(..3).step(10)")).should == [0]
@array.send(@method, eval("(...3).step(10)")).should == [0]
@array.send(@method, (..3).step(10)).should == [0]
@array.send(@method, (...3).step(10)).should == [0]
# end with negative index
@array.send(@method, eval("(..-2).step(1)")).should == [0, 1, 2, 3, 4,]
@array.send(@method, eval("(...-2).step(1)")).should == [0, 1, 2, 3]
@array.send(@method, (..-2).step(1)).should == [0, 1, 2, 3, 4,]
@array.send(@method, (...-2).step(1)).should == [0, 1, 2, 3]
@array.send(@method, eval("(..-2).step(2)")).should == [0, 2, 4]
@array.send(@method, eval("(...-2).step(2)")).should == [0, 2]
@array.send(@method, (..-2).step(2)).should == [0, 2, 4]
@array.send(@method, (...-2).step(2)).should == [0, 2]
@array.send(@method, eval("(..-2).step(10)")).should == [0]
@array.send(@method, eval("(...-2).step(10)")).should == [0]
@array.send(@method, (..-2).step(10)).should == [0]
@array.send(@method, (...-2).step(10)).should == [0]
end
it "has endless range and negative steps" do
@ -770,26 +770,24 @@ describe :array_slice, shared: true do
end
end
ruby_version_is "2.7" do
it "can accept beginless ranges" do
a = [0, 1, 2, 3, 4, 5]
a.send(@method, eval("(..3)")).should == [0, 1, 2, 3]
a.send(@method, eval("(...3)")).should == [0, 1, 2]
a.send(@method, eval("(..-3)")).should == [0, 1, 2, 3]
a.send(@method, eval("(...-3)")).should == [0, 1, 2]
a.send(@method, eval("(..0)")).should == [0]
a.send(@method, eval("(...0)")).should == []
a.send(@method, eval("(..9)")).should == [0, 1, 2, 3, 4, 5]
a.send(@method, eval("(...9)")).should == [0, 1, 2, 3, 4, 5]
a.send(@method, eval("(..-9)")).should == []
a.send(@method, eval("(...-9)")).should == []
a.send(@method, (..3)).should == [0, 1, 2, 3]
a.send(@method, (...3)).should == [0, 1, 2]
a.send(@method, (..-3)).should == [0, 1, 2, 3]
a.send(@method, (...-3)).should == [0, 1, 2]
a.send(@method, (..0)).should == [0]
a.send(@method, (...0)).should == []
a.send(@method, (..9)).should == [0, 1, 2, 3, 4, 5]
a.send(@method, (...9)).should == [0, 1, 2, 3, 4, 5]
a.send(@method, (..-9)).should == []
a.send(@method, (...-9)).should == []
end
it "can accept nil...nil ranges" do
a = [0, 1, 2, 3, 4, 5]
a.send(@method, eval("(nil...nil)")).should == a
a.send(@method, eval("(...nil)")).should == a
a.send(@method, (...nil)).should == a
a.send(@method, eval("(nil..)")).should == a
end
end
end

16
spec/ruby/core/array/shift_spec.rb
View file

@ -116,21 +116,5 @@ describe "Array#shift" do
it "does not return subclass instances with Array subclass" do
ArraySpecs::MyArray[1, 2, 3].shift(2).should be_an_instance_of(Array)
end
ruby_version_is ''...'2.7' do
it "returns an untainted array even if the array is tainted" do
ary = [1, 2].taint
ary.shift(2).tainted?.should be_false
ary.shift(0).tainted?.should be_false
end
it "keeps taint status" do
a = [1, 2].taint
a.shift(2)
a.tainted?.should be_true
a.shift(2)
a.tainted?.should be_true
end
end
end
end

6
spec/ruby/core/array/slice_spec.rb
View file

@ -172,17 +172,15 @@ describe "Array#slice!" do
a.should == [1, 2]
end
ruby_version_is "2.7" do
it "works with beginless ranges" do
a = [0,1,2,3,4]
a.slice!(eval("(..3)")).should == [0, 1, 2, 3]
a.slice!((..3)).should == [0, 1, 2, 3]
a.should == [4]
a = [0,1,2,3,4]
a.slice!(eval("(...-2)")).should == [0, 1, 2]
a.slice!((...-2)).should == [0, 1, 2]
a.should == [3, 4]
end
end
describe "with a subclass of Array" do
before :each do

44
spec/ruby/core/array/uniq_spec.rb
View file

@ -39,7 +39,6 @@ describe "Array#uniq" do
[x, y].uniq.should == [x, y]
end
ruby_version_is '2.7' do
it "compares elements with matching hash codes with #eql?" do
a = Array.new(2) do
obj = mock('0')
@ -67,49 +66,6 @@ describe "Array#uniq" do
a.uniq.size.should == 1
end
end
ruby_version_is ''...'2.7' do
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
obj
end
a.uniq.should == a
a[0].should.tainted?
a[1].should.tainted?
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
true
end
obj
end
a.uniq.size.should == 1
a[0].should.tainted?
a[1].should.tainted?
end
end
it "compares elements based on the value returned from the block" do
a = [1, 2, 3, 4]

6
spec/ruby/core/array/values_at_spec.rb
View file

@ -66,10 +66,8 @@ describe "Array#values_at" do
[1, 2, 3, 4].values_at(eval("(3...)")).should == [4]
end
ruby_version_is "2.7" do
it "works when given beginless ranges" do
[1, 2, 3, 4].values_at(eval("(..2)")).should == [1, 2, 3]
[1, 2, 3, 4].values_at(eval("(...2)")).should == [1, 2]
end
[1, 2, 3, 4].values_at((..2)).should == [1, 2, 3]
[1, 2, 3, 4].values_at((...2)).should == [1, 2]
end
end

8
spec/ruby/core/builtin_constants/builtin_constants_spec.rb
View file

@ -49,15 +49,7 @@ describe "RUBY_RELEASE_DATE" do
end
describe "RUBY_REVISION" do
ruby_version_is ""..."2.7" do
it "is an Integer" do
RUBY_REVISION.should be_kind_of(Integer)
end
end
ruby_version_is "2.7" do
it "is a String" do
RUBY_REVISION.should be_kind_of(String)
end
end
end

10
spec/ruby/core/comparable/clamp_spec.rb
View file

@ -2,14 +2,6 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe 'Comparable#clamp' do
ruby_version_is ""..."2.7" do
it 'raises an Argument error unless given 2 parameters' do
c = ComparableSpecs::Weird.new(0)
-> { c.clamp(c) }.should raise_error(ArgumentError)
-> { c.clamp(c, c, c) }.should raise_error(ArgumentError)
end
end
it 'raises an Argument error unless the 2 parameters are correctly ordered' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
@ -48,7 +40,6 @@ describe 'Comparable#clamp' do
c.clamp(one, two).should equal(two)
end
ruby_version_is "2.7" do
it 'returns self if within the given range parameters' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
@ -84,5 +75,4 @@ describe 'Comparable#clamp' do
-> { c.clamp(one...two) }.should raise_error(ArgumentError)
end
end
end

2
spec/ruby/core/complex/comparison_spec.rb
View file

@ -1,7 +1,6 @@
require_relative '../../spec_helper'
describe "Complex#<=>" do
ruby_version_is "2.7" do
it "returns nil if either self or argument has imaginary part" do
(Complex(5, 1) <=> Complex(2)).should be_nil
(Complex(1) <=> Complex(2, 1)).should be_nil
@ -23,5 +22,4 @@ describe "Complex#<=>" do
(Complex(2) <=> 3).should == -1
(Complex(2) <=> 2).should == 0
end
end
end

8
spec/ruby/core/dir/children_spec.rb
View file

@ -105,14 +105,6 @@ describe "Dir#children" do
dirs.each { |d| d.encoding.should == Encoding::UTF_8 }
end
ruby_version_is ""..."2.7" do
it "accepts nil options" do
@dir = Dir.new("#{DirSpecs.mock_dir}/deeply/nested", nil)
dirs = @dir.to_a.sort
dirs.each { |d| d.encoding.should == Encoding.find("filesystem") }
end
end
it "returns children encoded with the filesystem encoding by default" do
# This spec depends on the locale not being US-ASCII because if it is, the
# children that are not ascii_only? will be BINARY encoded.

7
spec/ruby/core/dir/each_child_spec.rb
View file

@ -15,13 +15,6 @@ describe "Dir.each_child" do
dirs.each {|dir| dir.encoding.should == Encoding::UTF_8}
end
ruby_version_is ""..."2.7" do
it "accepts nil options" do
dirs = Dir.each_child("#{DirSpecs.mock_dir}/deeply/nested", nil).to_a.sort
dirs.each {|dir| dir.encoding.should == Encoding.find("filesystem")}
end
end
it "yields all names in an existing directory to the provided block" do
a, b = [], []

7
spec/ruby/core/dir/entries_spec.rb
View file

@ -40,13 +40,6 @@ describe "Dir.entries" do
dirs.each {|dir| dir.encoding.should == Encoding::UTF_8}
end
ruby_version_is ""..."2.7" do
it "accepts nil options" do
dirs = Dir.entries("#{DirSpecs.mock_dir}/deeply/nested", nil).to_a.sort
dirs.each {|dir| dir.encoding.should == Encoding.find("filesystem")}
end
end
it "returns entries encoded with the filesystem encoding by default" do
# This spec depends on the locale not being US-ASCII because if it is, the
# entries that are not ascii_only? will be BINARY encoded.

7
spec/ruby/core/dir/foreach_spec.rb
View file

@ -51,13 +51,6 @@ describe "Dir.foreach" do
end
end
ruby_version_is ""..."2.7" do
it "accepts nil options" do
dirs = Dir.foreach("#{DirSpecs.mock_dir}/deeply/nested", nil).to_a.sort
dirs.each {|dir| dir.encoding.should == Encoding.find("filesystem")}
end
end
describe "when no block is given" do
it "returns an Enumerator" do
Dir.foreach(DirSpecs.mock_dir).should be_an_instance_of(Enumerator)

11
spec/ruby/core/dir/shared/glob.rb
View file

@ -23,20 +23,9 @@ describe :dir_glob, shared: true do
Dir.send(@method, obj).should == %w[file_one.ext]
end
ruby_version_is ""..."2.7" do
it "splits the string on \\0 if there is only one string given and warns" do
-> {
Dir.send(@method, "file_o*\0file_t*").should ==
%w!file_one.ext file_two.ext!
}.should complain(/warning: use glob patterns list instead of nul-separated patterns/)
end
end
ruby_version_is "2.7" do
it "raises an ArgumentError if the string contains \\0" do
-> {Dir.send(@method, "file_o*\0file_t*")}.should raise_error ArgumentError, /nul-separated/
end
end
ruby_version_is "3.0" do
it "result is sorted by default" do

2
spec/ruby/core/encoding/list_spec.rb
View file

@ -40,11 +40,9 @@ describe "Encoding.list" do
Encoding.list.should.include?(Encoding::UTF_8)
end
ruby_version_is "2.7" do
it 'includes CESU-8 encoding' do
Encoding.list.should.include?(Encoding::CESU_8)
end
end
# TODO: Find example that illustrates this
it "updates the list when #find is used to load a new encoding"

4
spec/ruby/core/enumerable/filter_map_spec.rb
View file

@ -1,8 +1,7 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is '2.7' do
describe 'Enumerable#filter_map' do
describe 'Enumerable#filter_map' do
before :each do
@numerous = EnumerableSpecs::Numerous.new(*(1..8).to_a)
end
@ -22,5 +21,4 @@ ruby_version_is '2.7' do
it 'returns an enumerator when no block given' do
@numerous.filter_map.should be_an_instance_of(Enumerator)
end
end
end

10
spec/ruby/core/enumerable/group_by_spec.rb
View file

@ -33,15 +33,5 @@ describe "Enumerable#group_by" do
[3, 4, 5] => [[3, 4, 5]] }
end
ruby_version_is ''...'2.7' do
it "returns a tainted hash if self is tainted" do
EnumerableSpecs::Empty.new.taint.group_by {}.tainted?.should be_true
end
it "returns an untrusted hash if self is untrusted" do
EnumerableSpecs::Empty.new.untrust.group_by {}.untrusted?.should be_true
end
end
it_behaves_like :enumerable_enumeratorized_with_origin_size, :group_by
end

10
spec/ruby/core/enumerable/shared/entries.rb
View file

@ -13,14 +13,4 @@ describe :enumerable_entries, shared: true do
count.send(@method, :hello, "world").should == [1, 2, 3]
count.arguments_passed.should == [:hello, "world"]
end
ruby_version_is ''...'2.7' do
it "returns a tainted array if self is tainted" do
EnumerableSpecs::Empty.new.taint.send(@method).tainted?.should be_true
end
it "returns an untrusted array if self is untrusted" do
EnumerableSpecs::Empty.new.untrust.send(@method).untrusted?.should be_true
end
end
end

3
spec/ruby/core/enumerable/shared/inject.rb
View file

@ -17,7 +17,8 @@ describe :enumerable_inject, shared: true do
end
it "ignores the block if two arguments" do
EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, :-){ raise "we never get here"}.should == 4
EnumerableSpecs::Numerous.new(1, 2, 3).send(@method, 10, :-) { raise "we never get here"}.should == 4
[].send(@method, 3, :+) { raise "we never get here"}.should == 3
end
it "can take a symbol argument" do

4
spec/ruby/core/enumerable/tally_spec.rb
View file

@ -1,8 +1,7 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" do
describe "Enumerable#tally" do
describe "Enumerable#tally" do
before :each do
ScratchPad.record []
end
@ -31,7 +30,6 @@ ruby_version_is "2.7" do
enum.tally { |v| ScratchPad << v }
ScratchPad.recorded.should == []
end
end
end
ruby_version_is "3.1" do

44
spec/ruby/core/enumerable/uniq_spec.rb
View file

@ -31,7 +31,6 @@ describe 'Enumerable#uniq' do
[x, y].to_enum.uniq.should == [x, y]
end
ruby_version_is '2.7' do
it "compares elements with matching hash codes with #eql?" do
a = Array.new(2) do
obj = mock('0')
@ -59,49 +58,6 @@ describe 'Enumerable#uniq' do
a.to_enum.uniq.size.should == 1
end
end
ruby_version_is ''...'2.7' do
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
obj
end
a.uniq.should == a
a[0].should.tainted?
a[1].should.tainted?
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
true
end
obj
end
a.to_enum.uniq.size.should == 1
a[0].should.tainted?
a[1].should.tainted?
end
end
context 'when yielded with multiple arguments' do
before :each do

6
spec/ruby/core/enumerator/arithmetic_sequence/begin_spec.rb
View file

@ -7,12 +7,10 @@ describe "Enumerator::ArithmeticSequence#begin" do
(1...10).step.begin.should == 1
end
ruby_version_is "2.7" do
context "with beginless" do
it "returns nil as begin of the sequence" do
eval("(..10).step(1)").begin.should == nil
eval("(...10).step(1)").begin.should == nil
end
(..10).step(1).begin.should == nil
(...10).step(1).begin.should == nil
end
end
end

4
spec/ruby/core/enumerator/lazy/eager_spec.rb
View file

@ -1,7 +1,6 @@
require_relative '../../../spec_helper'
ruby_version_is "2.7" do
describe "Enumerator::Lazy#eager" do
describe "Enumerator::Lazy#eager" do
it "returns a non-lazy Enumerator converted from the lazy enumerator" do
enum = [1, 2, 3].lazy
@ -25,5 +24,4 @@ ruby_version_is "2.7" do
enum.map { |i| i }.should == [1, 2, 3]
ScratchPad.recorded.should == [1, 2, 3]
end
end
end

4
spec/ruby/core/enumerator/lazy/filter_map_spec.rb
View file

@ -3,8 +3,7 @@
require_relative '../../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" do
describe "Enumerator::Lazy#filter_map" do
describe "Enumerator::Lazy#filter_map" do
it "maps only truthy results" do
(1..Float::INFINITY).lazy.filter_map { |i| i if i.odd? }.first(4).should == [1, 3, 5, 7]
end
@ -12,5 +11,4 @@ ruby_version_is "2.7" do
it "does not map false results" do
(1..Float::INFINITY).lazy.filter_map { |i| i.odd? ? i : false }.first(4).should == [1, 3, 5, 7]
end
end
end

4
spec/ruby/core/enumerator/lazy/with_index_spec.rb
View file

@ -3,8 +3,7 @@
require_relative '../../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" do
describe "Enumerator::Lazy#with_index" do
describe "Enumerator::Lazy#with_index" do
it "enumerates with an index" do
(0..Float::INFINITY).lazy.with_index.map { |i, idx| [i, idx] }.first(3).should == [[0, 0], [1, 1], [2, 2]]
end
@ -34,5 +33,4 @@ ruby_version_is "2.7" do
enum.each { |i, idx| result << [i, idx] }
result.should == [[0,0], [1,1], [2,2], [0,0], [1,1], [2,2]]
end
end
end

2
spec/ruby/core/enumerator/new_spec.rb
View file

@ -77,7 +77,6 @@ describe "Enumerator.new" do
enum.take(3).should == [1, 2, 3]
end
ruby_version_is "2.7" do
it "defines iteration with block, yielder argument and treating it as a proc" do
enum = Enumerator.new do |yielder|
"a\nb\nc".each_line(&yielder)
@ -85,7 +84,6 @@ describe "Enumerator.new" do
enum.to_a.should == ["a\n", "b\n", "c"]
end
end
describe 'yielded values' do
it 'handles yield arguments properly' do

4
spec/ruby/core/enumerator/produce_spec.rb
View file

@ -1,7 +1,6 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" do
describe "Enumerator.produce" do
describe "Enumerator.produce" do
it "creates an infinite enumerator" do
enum = Enumerator.produce(0) { |prev| prev + 1 }
enum.take(5).should == [0, 1, 2, 3, 4]
@ -32,5 +31,4 @@ ruby_version_is "2.7" do
lines.should == ["a\n", "b\n", "c\n", "d"]
end
end
end
end

4
spec/ruby/core/enumerator/yielder/to_proc_spec.rb
View file

@ -1,7 +1,6 @@
require_relative '../../../spec_helper'
ruby_version_is "2.7" do
describe "Enumerator::Yielder#to_proc" do
describe "Enumerator::Yielder#to_proc" do
it "returns a Proc object that takes an argument and yields it to the block" do
ScratchPad.record []
y = Enumerator::Yielder.new { |*args| ScratchPad << args; "foobar" }
@ -14,5 +13,4 @@ ruby_version_is "2.7" do
result.should == "foobar"
end
end
end

4
spec/ruby/core/env/merge_spec.rb vendored
View file

@ -1,8 +1,6 @@
require_relative '../../spec_helper'
require_relative 'shared/update'
ruby_version_is "2.7" do
describe "ENV.merge!" do
describe "ENV.merge!" do
it_behaves_like :env_update, :merge!
end
end

2
spec/ruby/core/env/shared/update.rb vendored
View file

@ -39,7 +39,6 @@ describe :env_update, shared: true do
ENV["bar"].should == "5"
end
ruby_version_is "2.7" do
# BUG: https://bugs.ruby-lang.org/issues/16192
it "does not evaluate the block when the name is new" do
ENV.delete("bar")
@ -56,7 +55,6 @@ describe :env_update, shared: true do
ENV["foo"].should == "0"
ENV["bar"].should == "1"
end
end
it "returns ENV when block given" do
ENV.send(@method, {"foo" => "0", "bar" => "1"}){}.should equal(ENV)

4
spec/ruby/core/exception/frozen_error_spec.rb
View file

@ -1,16 +1,13 @@
require_relative '../../spec_helper'
describe "FrozenError.new" do
ruby_version_is "2.7" do
it "should take optional receiver argument" do
o = Object.new
FrozenError.new("msg", receiver: o).receiver.should equal(o)
end
end
end
describe "FrozenError#receiver" do
ruby_version_is "2.7" do
it "should return frozen object that modification was attempted on" do
o = Object.new.freeze
begin
@ -22,5 +19,4 @@ describe "FrozenError#receiver" do
raise
end
end
end
end

2
spec/ruby/core/false/to_s_spec.rb
View file

@ -5,7 +5,6 @@ describe "FalseClass#to_s" do
false.to_s.should == "false"
end
ruby_version_is "2.7" do
it "returns a frozen string" do
false.to_s.should.frozen?
end
@ -13,5 +12,4 @@ describe "FalseClass#to_s" do
it "always returns the same string" do
false.to_s.should equal(false.to_s)
end
end
end

12
spec/ruby/core/fiber/raise_spec.rb
View file

@ -2,12 +2,11 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
require_relative '../../shared/kernel/raise'
ruby_version_is "2.7" do
describe "Fiber#raise" do
describe "Fiber#raise" do
it_behaves_like :kernel_raise, :raise, FiberSpecs::NewFiberToRaise
end
end
describe "Fiber#raise" do
describe "Fiber#raise" do
it 'raises RuntimeError by default' do
-> { FiberSpecs::NewFiberToRaise.raise }.should raise_error(RuntimeError)
end
@ -92,11 +91,10 @@ ruby_version_is "2.7" do
fiber_two.resume.should == [:yield_one, :rescued]
end
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
describe "Fiber#raise" do
it "raises a FiberError if invoked on a transferring Fiber" do
require "fiber"

4
spec/ruby/core/file/absolute_path_spec.rb
View file

@ -1,7 +1,6 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" do
describe "File.absolute_path?" do
describe "File.absolute_path?" do
before :each do
@abs = File.expand_path(__FILE__)
end
@ -50,7 +49,6 @@ ruby_version_is "2.7" do
File.absolute_path?("/foo/bar\\baz").should be_false
end
end
end
end
describe "File.absolute_path" do

4
spec/ruby/core/file/extname_spec.rb
View file

@ -33,14 +33,14 @@ describe "File.extname" do
end
describe "for a filename ending with a dot" do
guard -> { platform_is :windows or ruby_version_is ""..."2.7" } do
platform_is :windows do
it "returns ''" do
File.extname(".foo.").should == ""
File.extname("foo.").should == ""
end
end
guard -> { platform_is_not :windows and ruby_version_is "2.7" } do
platform_is_not :windows do
it "returns '.'" do
File.extname(".foo.").should == "."
File.extname("foo.").should == "."

13
spec/ruby/core/hash/constructor_spec.rb
View file

@ -42,18 +42,6 @@ describe "Hash.[]" do
Hash[ary].should == { a: :b }
end
ruby_version_is "" ... "2.7" do
it "ignores elements that are not arrays" do
-> {
Hash[[:a]].should == {}
}.should complain(/ignoring wrong elements/)
-> {
Hash[[:nil]].should == {}
}.should complain(/ignoring wrong elements/)
end
end
ruby_version_is "2.7" do
it "raises for elements that are not arrays" do
-> {
Hash[[:a]].should == {}
@ -62,7 +50,6 @@ describe "Hash.[]" do
Hash[[:nil]].should == {}
}.should raise_error(ArgumentError)
end
end
it "raises an ArgumentError for arrays of more than 2 elements" do
->{ Hash[[[:a, :b, :c]]].should == {} }.should raise_error(ArgumentError)

4
spec/ruby/core/hash/deconstruct_keys_spec.rb
View file

@ -1,7 +1,6 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" do
describe "Hash#deconstruct_keys" do
describe "Hash#deconstruct_keys" do
it "returns self" do
hash = {a: 1, b: 2}
@ -21,5 +20,4 @@ ruby_version_is "2.7" do
hash.deconstruct_keys(0 ).should == {a: 1, b: 2}
hash.deconstruct_keys('' ).should == {a: 1, b: 2}
end
end
end

7
spec/ruby/core/hash/reject_spec.rb
View file

@ -31,13 +31,6 @@ describe "Hash#reject" do
HashSpecs::MyHash[1 => 2, 3 => 4].reject { false }.should be_kind_of(Hash)
HashSpecs::MyHash[1 => 2, 3 => 4].reject { true }.should be_kind_of(Hash)
end
ruby_version_is ''...'2.7' do
it "does not taint the resulting hash" do
h = { a: 1 }.taint
h.reject {false}.should_not.tainted?
end
end
end
it "processes entries with the same order as reject!" do

8
spec/ruby/core/hash/ruby2_keywords_hash_spec.rb
View file

@ -1,8 +1,7 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" do
describe "Hash.ruby2_keywords_hash?" do
describe "Hash.ruby2_keywords_hash?" do
it "returns false if the Hash is not a keywords Hash" do
Hash.ruby2_keywords_hash?({}).should == false
end
@ -19,9 +18,9 @@ ruby_version_is "2.7" do
it "raises TypeError for non-Hash" do
-> { Hash.ruby2_keywords_hash?(nil) }.should raise_error(TypeError)
end
end
end
describe "Hash.ruby2_keywords_hash" do
describe "Hash.ruby2_keywords_hash" do
it "returns a copy of a Hash and marks the copy as a keywords Hash" do
h = {a: 1}.freeze
kw = Hash.ruby2_keywords_hash(h)
@ -57,5 +56,4 @@ ruby_version_is "2.7" do
it "raises TypeError for non-Hash" do
-> { Hash.ruby2_keywords_hash(nil) }.should raise_error(TypeError)
end
end
end

46
spec/ruby/core/hash/shared/eql.rb
View file

@ -149,7 +149,6 @@ describe :hash_eql_additional, shared: true do
h.send(@method, HashSpecs::MyHash[h]).should be_true
end
ruby_version_is '2.7' do
# Why isn't this true of eql? too ?
it "compares keys with matching hash codes via eql?" do
a = Array.new(2) do
@ -179,51 +178,6 @@ describe :hash_eql_additional, shared: true do
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_true
end
end
ruby_version_is ''...'2.7' do
# Why isn't this true of eql? too ?
it "compares keys with matching hash codes via eql?" do
a = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
# It's undefined whether the impl does a[0].eql?(a[1]) or
# a[1].eql?(a[0]) so we taint both.
def obj.eql?(o)
return true if self.equal?(o)
taint
o.taint
false
end
obj
end
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_false
a[0].tainted?.should be_true
a[1].tainted?.should be_true
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].send(@method, a[1]) or
# a[1].send(@method, a[0]) so we taint both.
taint
o.taint
true
end
obj
end
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_true
a[0].tainted?.should be_true
a[1].tainted?.should be_true
end
end
it "compares the values in self to values in other hash" do
l_val = mock("left")

12
spec/ruby/core/hash/shared/to_s.rb
View file

@ -76,18 +76,6 @@ describe :hash_to_s, shared: true do
y.send(@method).should == "{1=>{0=>{...}}}"
end
ruby_version_is ''...'2.7' do
it "returns a tainted string if self is tainted and not empty" do
{}.taint.send(@method).tainted?.should be_false
{ nil => nil }.taint.send(@method).tainted?.should be_true
end
it "returns an untrusted string if self is untrusted and not empty" do
{}.untrust.send(@method).untrusted?.should be_false
{ nil => nil }.untrust.send(@method).untrusted?.should be_true
end
end
it "does not raise if inspected result is not default external encoding" do
utf_16be = mock("utf_16be")
utf_16be.should_receive(:inspect).and_return(%<"utf_16be \u3042">.encode!(Encoding::UTF_16BE))

12
spec/ruby/core/hash/to_a_spec.rb
View file

@ -27,17 +27,7 @@ describe "Hash#to_a" do
ent.should == pairs
end
ruby_version_is ''...'2.7' do
it "returns a tainted array if self is tainted" do
{}.taint.to_a.tainted?.should be_true
end
it "returns an untrusted array if self is untrusted" do
{}.untrust.to_a.untrusted?.should be_true
end
end
ruby_version_is '2.7'...'3.0' do
ruby_version_is ''...'3.0' do
it "returns a not tainted array if self is tainted" do
{}.taint.to_a.tainted?.should be_false
end

2
spec/ruby/core/integer/chr_spec.rb
View file

@ -245,7 +245,6 @@ describe "Integer#chr with an encoding argument" do
end
end
ruby_version_is "2.7" do
it 'returns a String encoding self interpreted as a codepoint in the CESU-8 encoding' do
# see more details here https://en.wikipedia.org/wiki/CESU-8
# code points from U+0000 to U+FFFF is encoded in the same way as in UTF-8
@ -256,5 +255,4 @@ describe "Integer#chr with an encoding argument" do
0x10400.chr(Encoding::CESU_8).bytes.should != 0x10400.chr(Encoding::UTF_8).bytes
0x10400.chr(Encoding::CESU_8).bytes.to_a.should == [0xED, 0xA0, 0x81, 0xED, 0xB0, 0x80]
end
end
end

2
spec/ruby/core/integer/element_reference_spec.rb
View file

@ -79,7 +79,6 @@ describe "Integer#[]" do
3[bignum_value.to_f].should == 0
end
ruby_version_is "2.7" do
context "when index and length passed" do
it "returns specified number of bits from specified position" do
0b101001101[2, 4].should == 0b0011
@ -157,7 +156,6 @@ describe "Integer#[]" do
end
end
end
end
context "bignum" do
before :each do

46
spec/ruby/core/integer/fdiv_spec.rb
View file

@ -9,6 +9,52 @@ describe "Integer#fdiv" do
8.fdiv(bignum_value).should be_close(8.673617379884035e-19, TOLERANCE)
end
it "performs floating-point division between self bignum and a bignum" do
num = 1000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146010000000000000000000000000000000000048148248609680896326399448564623182963452541226153892315137780403285956264146009
den = 2000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
num.fdiv(den).should == 500.0
end
it "rounds to the correct value for bignums" do
den = 9 * 10**342
num = 1 * 10**344
num.fdiv(den).should == 11.11111111111111
num = 1 * 10**343
num.fdiv(den).should == 1.1111111111111112
num = 1 * 10**342
num.fdiv(den).should == 0.1111111111111111
num = 2 * 10**342
num.fdiv(den).should == 0.2222222222222222
num = 3 * 10**342
num.fdiv(den).should == 0.3333333333333333
num = 4 * 10**342
num.fdiv(den).should == 0.4444444444444444
num = 5 * 10**342
num.fdiv(den).should == 0.5555555555555556
num = 6 * 10**342
num.fdiv(den).should == 0.6666666666666666
num = 7 * 10**342
num.fdiv(den).should == 0.7777777777777778
num = 8 * 10**342
num.fdiv(den).should == 0.8888888888888888
num = 9 * 10**342
num.fdiv(den).should == 1.0
num = -5 * 10**342
num.fdiv(den).should == -0.5555555555555556
end
it "performs floating-point division between self and a Float" do
8.fdiv(9.0).should be_close(0.888888888888889, TOLERANCE)
end

32
spec/ruby/core/io/gets_spec.rb
View file

@ -38,14 +38,6 @@ describe "IO#gets" do
IOSpecs.lines.each { |line| line.should == @io.gets }
end
ruby_version_is ''...'2.7' do
it "returns tainted strings" do
while line = @io.gets
line.should.tainted?
end
end
end
it "updates lineno with each invocation" do
while @io.gets
@io.lineno.should == @count += 1
@ -64,14 +56,6 @@ describe "IO#gets" do
@io.gets(nil).should == IOSpecs.lines.join("")
end
ruby_version_is ''...'2.7' do
it "returns tainted strings" do
while line = @io.gets(nil)
line.should.tainted?
end
end
end
it "updates lineno with each invocation" do
while @io.gets(nil)
@io.lineno.should == @count += 1
@ -100,14 +84,6 @@ describe "IO#gets" do
@io.gets.should == IOSpecs.lines[4]
end
ruby_version_is ''...'2.7' do
it "returns tainted strings" do
while line = @io.gets("")
line.should.tainted?
end
end
end
it "updates lineno with each invocation" do
while @io.gets("")
@io.lineno.should == @count += 1
@ -126,14 +102,6 @@ describe "IO#gets" do
@io.gets("la linea").should == "Voici la ligne une.\nQui \303\250 la linea"
end
ruby_version_is ''...'2.7' do
it "returns tainted strings" do
while line = @io.gets("la")
line.should.tainted?
end
end
end
it "updates lineno with each invocation" do
while (@io.gets("la"))
@io.lineno.should == @count += 1

2
spec/ruby/core/io/set_encoding_by_bom_spec.rb
View file

@ -12,7 +12,6 @@ describe "IO#set_encoding_by_bom" do
rm_r @name
end
ruby_version_is "2.7" do
it "returns the result encoding if found BOM UTF-8 sequence" do
File.binwrite(@name, "\u{FEFF}abc")
@ -73,5 +72,4 @@ describe "IO#set_encoding_by_bom" do
-> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding conversion is set')
end
end
end

10
spec/ruby/core/io/ungetbyte_spec.rb
View file

@ -36,22 +36,12 @@ describe "IO#ungetbyte" do
@io.getbyte.should == 97
end
ruby_version_is ''...'2.6.1' do
it "is an RangeError if the integer is not in 8bit" do
for i in [4095, 0x4f7574206f6620636861722072616e6765] do
-> { @io.ungetbyte(i) }.should raise_error(RangeError)
end
end
end
ruby_version_is '2.6.1' do
it "never raises RangeError" do
for i in [4095, 0x4f7574206f6620636861722072616e67ff] do
@io.ungetbyte(i).should be_nil
@io.getbyte.should == 255
end
end
end
it "raises IOError on stream not opened for reading" do
-> { STDOUT.ungetbyte(42) }.should raise_error(IOError, "not opened for reading")

6
spec/ruby/core/kernel/caller_locations_spec.rb
View file

@ -34,12 +34,10 @@ describe 'Kernel#caller_locations' do
locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
end
ruby_version_is "2.7" do
it "works with beginless ranges" do
locations1 = caller_locations(0)
locations2 = caller_locations(eval("(...5)"))
locations2.map(&:to_s)[eval("(2..)")].should == locations1[eval("(...5)")].map(&:to_s)[eval("(2..)")]
end
locations2 = caller_locations((...5))
locations2.map(&:to_s)[eval("(2..)")].should == locations1[(...5)].map(&:to_s)[eval("(2..)")]
end
it "can be called with a range whose end is negative" do

6
spec/ruby/core/kernel/caller_spec.rb
View file

@ -50,12 +50,10 @@ describe 'Kernel#caller' do
locations2.map(&:to_s).should == locations1[2..-1].map(&:to_s)
end
ruby_version_is "2.7" do
it "works with beginless ranges" do
locations1 = KernelSpecs::CallerTest.locations(0)
locations2 = KernelSpecs::CallerTest.locations(eval("(..5)"))
locations2.map(&:to_s)[eval("(2..)")].should == locations1[eval("(..5)")].map(&:to_s)[eval("(2..)")]
end
locations2 = KernelSpecs::CallerTest.locations((..5))
locations2.map(&:to_s)[eval("(2..)")].should == locations1[(..5)].map(&:to_s)[eval("(2..)")]
end
guard -> { Kernel.instance_method(:tap).source_location } do

7
spec/ruby/core/kernel/clone_spec.rb
View file

@ -206,11 +206,4 @@ describe "Kernel#clone" do
cloned.bar.should == ['a']
end
ruby_version_is ''...'2.7' do
it 'copies tainted?' do
o = ''.taint.clone
o.tainted?.should be_true
end
end
end

10
spec/ruby/core/kernel/inspect_spec.rb
View file

@ -6,16 +6,6 @@ describe "Kernel#inspect" do
Object.new.inspect.should be_an_instance_of(String)
end
ruby_version_is ''...'2.7' do
it "returns a tainted string if self is tainted" do
Object.new.taint.inspect.tainted?.should be_true
end
it "returns an untrusted string if self is untrusted" do
Object.new.untrust.inspect.untrusted?.should be_true
end
end
it "does not call #to_s if it is defined" do
# We must use a bare Object here
obj = Object.new

24
spec/ruby/core/kernel/method_spec.rb
View file

@ -34,4 +34,28 @@ describe "Kernel#method" do
m.should be_an_instance_of(Method)
m.call(1, 2, 3).should == "Done handled_privately([1, 2, 3])"
end
it "can call a #method_missing accepting zero or one arguments" do
cls = Class.new do
def respond_to_missing?(name, *)
name == :foo or super
end
def method_missing
:no_args
end
end
m = cls.new.method(:foo)
-> { m.call }.should raise_error(ArgumentError)
cls = Class.new do
def respond_to_missing?(name, *)
name == :bar or super
end
def method_missing(m)
m
end
end
m = cls.new.method(:bar)
m.call.should == :bar
end
end

10
spec/ruby/core/kernel/proc_spec.rb
View file

@ -40,15 +40,7 @@ describe "Kernel#proc" do
proc
end
ruby_version_is ""..."2.7" do
it "uses the implicit block from an enclosing method" do
prc = some_method { "hello" }
prc.call.should == "hello"
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "can be created when called with no block" do
-> {
some_method { "hello" }

24
spec/ruby/core/kernel/shared/dup_clone.rb
View file

@ -52,18 +52,6 @@ describe :kernel_dup_clone, shared: true do
o2.original.should equal(o)
end
ruby_version_is ''...'2.7' do
it "preserves tainted state from the original" do
o = ObjectSpecDupInitCopy.new
o2 = o.send(@method)
o.taint
o3 = o.send(@method)
o2.should_not.tainted?
o3.should.tainted?
end
end
it "does not preserve the object_id" do
o1 = ObjectSpecDupInitCopy.new
old_object_id = o1.object_id
@ -71,18 +59,6 @@ describe :kernel_dup_clone, shared: true do
o2.object_id.should_not == old_object_id
end
ruby_version_is ''...'2.7' do
it "preserves untrusted state from the original" do
o = ObjectSpecDupInitCopy.new
o2 = o.send(@method)
o.untrust
o3 = o.send(@method)
o2.should_not.untrusted?
o3.should.untrusted?
end
end
it "returns nil for NilClass" do
nil.send(@method).should == nil
end

4
spec/ruby/core/kernel/shared/require.rb
View file

@ -251,7 +251,7 @@ describe :kernel_require, shared: true do
ScratchPad.recorded.should == [:loaded]
end
ruby_bug "#16926", "2.7"..."3.0" do
ruby_bug "#16926", ""..."3.0" do
it "does not load a feature twice when $LOAD_PATH has been modified" do
$LOAD_PATH.replace [CODE_LOADING_DIR]
@object.require("load_fixture").should be_true
@ -547,9 +547,7 @@ describe :kernel_require, shared: true do
end
provided = %w[complex enumerator rational thread]
ruby_version_is "2.7" do
provided << 'ruby2_keywords'
end
it "#{provided.join(', ')} are already required" do
features = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems')

45
spec/ruby/core/kernel/taint_spec.rb
View file

@ -2,50 +2,7 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Kernel#taint" do
ruby_version_is ''...'2.7' do
it "returns self" do
o = Object.new
o.taint.should equal(o)
end
it "sets the tainted bit" do
o = Object.new
o.taint
o.should.tainted?
end
it "raises FrozenError on an untainted, frozen object" do
o = Object.new.freeze
-> { o.taint }.should raise_error(FrozenError)
end
it "does not raise an error on a tainted, frozen object" do
o = Object.new.taint.freeze
o.taint.should equal(o)
end
it "has no effect on immediate values" do
[nil, true, false].each do |v|
v.taint
v.should_not.tainted?
end
end
it "no raises a RuntimeError on symbols" do
v = :sym
-> { v.taint }.should_not raise_error(RuntimeError)
v.should_not.tainted?
end
it "no raises error on integer values" do
[1].each do |v|
-> { v.taint }.should_not raise_error(RuntimeError)
v.should_not.tainted?
end
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "is a no-op" do
o = Object.new
o.taint

12
spec/ruby/core/kernel/tainted_spec.rb
View file

@ -2,17 +2,7 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Kernel#tainted?" do
ruby_version_is ''...'2.7' do
it "returns true if Object is tainted" do
o = mock('o')
p = mock('p')
p.taint
o.should_not.tainted?
p.should.tainted?
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "is a no-op" do
o = mock('o')
p = mock('p')

10
spec/ruby/core/kernel/to_s_spec.rb
View file

@ -5,14 +5,4 @@ describe "Kernel#to_s" do
it "returns a String containing the name of self's class" do
Object.new.to_s.should =~ /Object/
end
ruby_version_is ''...'2.7' do
it "returns a tainted result if self is tainted" do
Object.new.taint.to_s.tainted?.should be_true
end
it "returns an untrusted result if self is untrusted" do
Object.new.untrust.to_s.untrusted?.should be_true
end
end
end

25
spec/ruby/core/kernel/trust_spec.rb
View file

@ -2,30 +2,7 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Kernel#trust" do
ruby_version_is ''...'2.7' do
it "returns self" do
o = Object.new
o.trust.should equal(o)
end
it "clears the untrusted bit" do
o = Object.new.untrust
o.trust
o.should_not.untrusted?
end
it "raises FrozenError on an untrusted, frozen object" do
o = Object.new.untrust.freeze
-> { o.trust }.should raise_error(FrozenError)
end
it "does not raise an error on a trusted, frozen object" do
o = Object.new.freeze
o.trust.should equal(o)
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "is a no-op" do
o = Object.new.untrust
o.should_not.untrusted?

25
spec/ruby/core/kernel/untaint_spec.rb
View file

@ -2,30 +2,7 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Kernel#untaint" do
ruby_version_is ''...'2.7' do
it "returns self" do
o = Object.new
o.untaint.should equal(o)
end
it "clears the tainted bit" do
o = Object.new.taint
o.untaint
o.should_not.tainted?
end
it "raises FrozenError on a tainted, frozen object" do
o = Object.new.taint.freeze
-> { o.untaint }.should raise_error(FrozenError)
end
it "does not raise an error on an untainted, frozen object" do
o = Object.new.freeze
o.untaint.should equal(o)
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "is a no-op" do
o = Object.new.taint
o.should_not.tainted?

25
spec/ruby/core/kernel/untrust_spec.rb
View file

@ -2,30 +2,7 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Kernel#untrust" do
ruby_version_is ''...'2.7' do
it "returns self" do
o = Object.new
o.untrust.should equal(o)
end
it "sets the untrusted bit" do
o = Object.new
o.untrust
o.should.untrusted?
end
it "raises FrozenError on a trusted, frozen object" do
o = Object.new.freeze
-> { o.untrust }.should raise_error(FrozenError)
end
it "does not raise an error on an untrusted, frozen object" do
o = Object.new.untrust.freeze
o.untrust.should equal(o)
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "is a no-op" do
o = Object.new
o.untrust

28
spec/ruby/core/kernel/untrusted_spec.rb
View file

@ -2,33 +2,7 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "Kernel#untrusted?" do
ruby_version_is ''...'2.7' do
it "returns the untrusted status of an object" do
o = mock('o')
o.should_not.untrusted?
o.untrust
o.should.untrusted?
end
it "has no effect on immediate values" do
a = nil
b = true
c = false
a.untrust
b.untrust
c.untrust
a.should_not.untrusted?
b.should_not.untrusted?
c.should_not.untrusted?
end
it "has effect on immediate values" do
d = 1
-> { d.untrust }.should_not raise_error(RuntimeError)
end
end
ruby_version_is "2.7"..."3.0" do
ruby_version_is ""..."3.0" do
it "is a no-op" do
o = mock('o')
o.should_not.untrusted?

4
spec/ruby/core/main/ruby2_keywords_spec.rb
View file

@ -1,11 +1,9 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" do
describe "main.ruby2_keywords" do
describe "main.ruby2_keywords" do
it "is the same as Object.ruby2_keywords" do
main = TOPLEVEL_BINDING.receiver
main.should have_private_method(:ruby2_keywords)
end
end
end

26
spec/ruby/core/marshal/dump_spec.rb
View file

@ -604,30 +604,4 @@ describe "Marshal.dump" do
m = Mutex.new
-> { Marshal.dump(m) }.should raise_error(TypeError)
end
ruby_version_is ''...'2.7' do
it "returns an untainted string if object is untainted" do
Marshal.dump(Object.new).tainted?.should be_false
end
it "returns a tainted string if object is tainted" do
Marshal.dump(Object.new.taint).tainted?.should be_true
end
it "returns a tainted string if nested object is tainted" do
Marshal.dump([[Object.new.taint]]).tainted?.should be_true
end
it "returns a trusted string if object is trusted" do
Marshal.dump(Object.new).untrusted?.should be_false
end
it "returns an untrusted string if object is untrusted" do
Marshal.dump(Object.new.untrust).untrusted?.should be_true
end
it "returns an untrusted string if nested object is untrusted" do
Marshal.dump([[Object.new.untrust]]).untrusted?.should be_true
end
end
end

83
spec/ruby/core/marshal/shared/load.rb
View file

@ -306,89 +306,6 @@ describe :marshal_load, shared: true do
end
end
ruby_version_is ''...'2.7' do
it "returns an untainted object if source is untainted" do
x = Object.new
y = Marshal.send(@method, Marshal.dump(x))
y.tainted?.should be_false
end
describe "when source is tainted" do
it "returns a tainted object" do
x = Object.new
x.taint
s = Marshal.dump(x)
y = Marshal.send(@method, s)
y.tainted?.should be_true
# note that round-trip via Marshal does not preserve
# the taintedness at each level of the nested structure
y = Marshal.send(@method, Marshal.dump([[x]]))
y.tainted?.should be_true
y.first.tainted?.should be_true
y.first.first.tainted?.should be_true
end
it "does not taint Symbols" do
x = [:x]
y = Marshal.send(@method, Marshal.dump(x).taint)
y.tainted?.should be_true
y.first.tainted?.should be_false
end
it "does not taint Fixnums" do
x = [1]
y = Marshal.send(@method, Marshal.dump(x).taint)
y.tainted?.should be_true
y.first.tainted?.should be_false
end
it "does not taint Bignums" do
x = [bignum_value]
y = Marshal.send(@method, Marshal.dump(x).taint)
y.tainted?.should be_true
y.first.tainted?.should be_false
end
it "does not taint Floats" do
x = [1.2]
y = Marshal.send(@method, Marshal.dump(x).taint)
y.tainted?.should be_true
y.first.tainted?.should be_false
end
end
it "preserves taintedness of nested structure" do
x = Object.new
a = [[x]]
x.taint
y = Marshal.send(@method, Marshal.dump(a))
y.tainted?.should be_true
y.first.tainted?.should be_true
y.first.first.tainted?.should be_true
end
it "returns a trusted object if source is trusted" do
x = Object.new
y = Marshal.send(@method, Marshal.dump(x))
y.untrusted?.should be_false
end
it "returns an untrusted object if source is untrusted" do
x = Object.new
x.untrust
y = Marshal.send(@method, Marshal.dump(x))
y.untrusted?.should be_true
# note that round-trip via Marshal does not preserve
# the untrustedness at each level of the nested structure
y = Marshal.send(@method, Marshal.dump([[x]]))
y.untrusted?.should be_true
y.first.untrusted?.should be_true
y.first.first.untrusted?.should be_true
end
end
# Note: Ruby 1.9 should be compatible with older marshal format
MarshalSpec::DATA.each do |description, (object, marshal, attributes)|
it "loads a #{description}" do

2
spec/ruby/core/matchdata/allocate_spec.rb
View file

@ -1,10 +1,8 @@
require_relative '../../spec_helper'
describe "MatchData.allocate" do
ruby_version_is "2.7" do
it "is undefined" do
# https://bugs.ruby-lang.org/issues/16294
-> { MatchData.allocate }.should raise_error(NoMethodError)
end
end
end

6
spec/ruby/core/matchdata/element_reference_spec.rb
View file

@ -16,6 +16,12 @@ describe "MatchData#[]" do
it "supports accessors [start, length]" do
/(.)(.)(\d+)(\d)/.match("THX1138.")[1, 2].should == %w|H X|
/(.)(.)(\d+)(\d)/.match("THX1138.")[-3, 2].should == %w|X 113|
# negative index is larger than the number of match values
/(.)(.)(\d+)(\d)/.match("THX1138.")[-30, 2].should == nil
# length argument larger than number of match values is capped to match value length
/(.)(.)(\d+)(\d)/.match("THX1138.")[3, 10].should == %w|113 8|
end
it "supports ranges [start..end]" do

18
spec/ruby/core/matchdata/post_match_spec.rb
View file

@ -7,24 +7,6 @@ describe "MatchData#post_match" do
$'.should == ': The Movie'
end
ruby_version_is ''...'2.7' do
it "keeps taint status from the source string" do
str = "THX1138: The Movie"
str.taint
res = /(.)(.)(\d+)(\d)/.match(str).post_match
res.tainted?.should be_true
$'.tainted?.should be_true
end
it "keeps untrusted status from the source string" do
str = "THX1138: The Movie"
str.untrust
res = /(.)(.)(\d+)(\d)/.match(str).post_match
res.untrusted?.should be_true
$'.untrusted?.should be_true
end
end
it "sets the encoding to the encoding of the source String" do
str = "abc".force_encoding Encoding::EUC_JP
str.match(/b/).post_match.encoding.should equal(Encoding::EUC_JP)

18
spec/ruby/core/matchdata/pre_match_spec.rb
View file

@ -7,24 +7,6 @@ describe "MatchData#pre_match" do
$`.should == 'T'
end
ruby_version_is ''...'2.7' do
it "keeps taint status from the source string" do
str = "THX1138: The Movie"
str.taint
res = /(.)(.)(\d+)(\d)/.match(str).pre_match
res.tainted?.should be_true
$`.tainted?.should be_true
end
it "keeps untrusted status from the source string" do
str = "THX1138: The Movie"
str.untrust
res = /(.)(.)(\d+)(\d)/.match(str).pre_match
res.untrusted?.should be_true
$`.untrusted?.should be_true
end
end
it "sets the encoding to the encoding of the source String" do
str = "abc".force_encoding Encoding::EUC_JP
str.match(/b/).pre_match.encoding.should equal(Encoding::EUC_JP)

6
spec/ruby/core/method/shared/to_s.rb
View file

@ -24,7 +24,6 @@ describe :method_to_s, shared: true do
@string.should =~ /\#bar/
end
ruby_version_is "2.7" do
it "returns a String containing method arguments" do
obj = MethodSpecs::Methods.new
obj.method(:zero).send(@method).should.include?("()")
@ -37,7 +36,6 @@ describe :method_to_s, shared: true do
obj.method(:zero_with_double_splat).send(@method).should.include?("(**a)")
obj.method(:one_req_one_opt_with_splat_and_block).send(@method).should.include?("(a, b=..., *c, &blk)")
end
end
it "returns a String containing the Module the method is defined in" do
@string.should =~ /MethodSpecs::MyMod/
@ -79,11 +77,9 @@ describe :method_to_s, shared: true do
@string.should.start_with? "#<Method: #<MethodSpecs::MySub:0xXXXXXX>.bar"
end
ruby_version_is '2.7' do
ruby_bug '#17428', '2.7'...'3.0' do
ruby_bug '#17428', ''...'3.0' do
it "shows the metaclass and the owner for a Module instance method retrieved from a class" do
String.method(:include).inspect.should.start_with?("#<Method: #<Class:String>(Module)#include")
end
end
end
end

14
spec/ruby/core/module/append_features_spec.rb
View file

@ -47,20 +47,6 @@ describe "Module#append_features" do
end
ruby_version_is ''...'2.7' do
it "copies own tainted status to the given module" do
other = Module.new
Module.new.taint.send :append_features, other
other.tainted?.should be_true
end
it "copies own untrusted status to the given module" do
other = Module.new
Module.new.untrust.send :append_features, other
other.untrusted?.should be_true
end
end
describe "when other is frozen" do
before :each do
@receiver = Module.new

4
spec/ruby/core/module/autoload_spec.rb
View file

@ -18,7 +18,6 @@ describe "Module#autoload?" do
ModuleSpecs::Autoload::Child.autoload?(:AnotherAutoload).should == "another_autoload.rb"
end
ruby_version_is "2.7" do
it "returns nil if an ancestor defined that autoload but recursion is disabled" do
ModuleSpecs::Autoload::Parent.autoload :InheritedAutoload, "inherited_autoload.rb"
ModuleSpecs::Autoload::Child.autoload?(:InheritedAutoload, false).should be_nil
@ -28,7 +27,6 @@ describe "Module#autoload?" do
ModuleSpecs::Autoload::Child.autoload :ChildAutoload, "child_autoload.rb"
ModuleSpecs::Autoload::Child.autoload?(:ChildAutoload, false).should == "child_autoload.rb"
end
end
end
describe "Module#autoload" do
@ -514,10 +512,8 @@ describe "Module#autoload" do
it "does not load the file when accessing the constants table of the module" do
ModuleSpecs::Autoload.autoload :P, @non_existent
ModuleSpecs::Autoload.const_defined?(:P).should be_true
ruby_bug "[Bug #15780]", ""..."2.7" do
ModuleSpecs::Autoload.const_defined?("P").should be_true
end
end
it "loads the file when opening a module that is the autoloaded constant" do
module ModuleSpecs::Autoload::U

Some files were not shown because too many files have changed in this diff Show more