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

45
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
it "enables deprecation warnings" do
ruby_exe('p Warning[:deprecated]', options: '-W:deprecated').should == "true\n"
end
end
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
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
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
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
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
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
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

6
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
it "enables both deprecated and experimental warnings" do
ruby_exe('p Warning[:deprecated]; p Warning[:experimental]', options: '-w').should == "true\ntrue\n"
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")

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

@ -59,24 +59,22 @@ 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')
result.should == ""
end
it "suppresses deprecation warnings for '-W:no-deprecated'" do
ENV["RUBYOPT"] = '-W:no-deprecated'
result = ruby_exe('$; = ""', args: '2>&1')
result.should == ""
end
it "suppresses experimental warnings for '-W:no-experimental'" do
ENV["RUBYOPT"] = '-W:no-experimental'
result = ruby_exe('case 0; in a; end', args: '2>&1')
result.should == ""
end
it "suppresses experimental warnings for '-W:no-experimental'" do
ENV["RUBYOPT"] = '-W:no-experimental'
result = ruby_exe('case 0; in a; end', args: '2>&1')
result.should == ""
end
it "suppresses deprecation and experimental warnings for '-W:no-deprecated -W:no-experimental'" do
ENV["RUBYOPT"] = '-W:no-deprecated -W:no-experimental'
result = ruby_exe('case ($; = ""); in a; end', args: '2>&1')
result.should == ""
end
it "suppresses deprecation and experimental warnings for '-W:no-deprecated -W:no-experimental'" do
ENV["RUBYOPT"] = '-W:no-deprecated -W:no-experimental'
result = ruby_exe('case ($; = ""); in a; end', args: '2>&1')
result.should == ""
end
it "requires the file for '-r'" do

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 }

10
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
it "returns self" do
array = [1]
describe "Array#deconstruct" do
it "returns self" do
array = [1]
array.deconstruct.should equal array
end
array.deconstruct.should equal array
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

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

@ -481,50 +481,48 @@ describe "Array#[]= with [m..]" do
end
end
ruby_version_is "2.7" 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.should == [nil, 4, 5]
a[eval("(...2)")] = nil
a.should == [nil, 5]
end
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[(..2)] = nil
a.should == [nil, 4, 5]
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.should == [nil, 4, 5]
a[eval("(...-1)")] = [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[(..-3)] = nil
a.should == [nil, 4, 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.should == [9, 3, 2, 1]
a[eval("(..2)")] = [7, 7, 7, 7, 7]
a.should == [7, 7, 7, 7, 7, 1]
end
it "replaces the section defined by range" do
a = [6, 5, 4, 3, 2, 1]
a[(...3)] = 9
a.should == [9, 3, 2, 1]
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.should == [7, 8, 9, 5]
end
it "replaces the section if n < 0" do
a = [1, 2, 3, 4, 5]
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.should == [4]
end
it "replaces everything if n > the array size" do
a = [1, 2, 3]
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.should == [4, 1, 2, 3]
a[eval("(...-10)")] = [6]
a.should == [6, 4, 1, 2, 3]
end
it "inserts at the beginning if n < negative the array size" do
a = [1, 2, 3]
a[(..-7)] = [4]
a.should == [4, 1, 2, 3]
a[(...-10)] = [6]
a.should == [6, 4, 1, 2, 3]
end
end

8
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
it "works with beginless ranges" do
[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]

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

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

86
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,18 +84,16 @@ 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
$, = '*'
end
context "when $, is not nil" do
before do
suppress_warning do
$, = '*'
end
end
it "warns" do
-> { [].join }.should complain(/warning: \$, is set to non-nil value/)
-> { [].join(nil) }.should complain(/warning: \$, is set to non-nil value/)
end
it "warns" do
-> { [].join }.should complain(/warning: \$, is set to non-nil value/)
-> { [].join(nil) }.should complain(/warning: \$, is set to non-nil value/)
end
end
end
@ -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

74
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 == []
end
it "can accept beginless ranges" do
a = [0, 1, 2, 3, 4, 5]
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, eval("(nil..)")).should == a
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, (...nil)).should == a
a.send(@method, eval("(nil..)")).should == a
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

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

@ -172,16 +172,14 @@ 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.should == [4]
it "works with beginless ranges" do
a = [0,1,2,3,4]
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.should == [3, 4]
end
a = [0,1,2,3,4]
a.slice!((...-2)).should == [0, 1, 2]
a.should == [3, 4]
end
describe "with a subclass of Array" do

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

@ -39,76 +39,32 @@ 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')
obj.should_receive(:hash).at_least(1).and_return(0)
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)
false
end
obj
def obj.eql?(o)
false
end
a.uniq.should == a
a = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
def obj.eql?(o)
true
end
obj
end
a.uniq.size.should == 1
obj
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)
a.uniq.should == a
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 = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
obj
def obj.eql?(o)
true
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?
obj
end
a.uniq.size.should == 1
end
it "compares elements based on the value returned from the block" do

8
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
it "works when given beginless ranges" do
[1, 2, 3, 4].values_at((..2)).should == [1, 2, 3]
[1, 2, 3, 4].values_at((...2)).should == [1, 2]
end
end

12
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
it "is a String" do
RUBY_REVISION.should be_kind_of(String)
end
end

64
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,41 +40,39 @@ 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)
three = ComparableSpecs::WithOnlyCompareDefined.new(3)
c = ComparableSpecs::Weird.new(2)
it 'returns self if within the given range 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
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 minimum value of the range parameters if smaller than it' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(0)
it 'returns the minimum value of the range parameters 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
c.clamp(one..two).should equal(one)
end
it 'returns the maximum value of the range parameters if greater than it' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
it 'returns the maximum value of the range parameters 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
c.clamp(one..two).should equal(two)
end
it 'raises an Argument error if the range parameter is exclusive' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
it 'raises an Argument error if the range parameter is exclusive' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
-> { c.clamp(one...two) }.should raise_error(ArgumentError)
end
-> { c.clamp(one...two) }.should raise_error(ArgumentError)
end
end

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

@ -1,27 +1,25 @@
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
(5 <=> Complex(2, 1)).should be_nil
end
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
(5 <=> Complex(2, 1)).should be_nil
end
it "returns nil if argument is not numeric" do
(Complex(5, 1) <=> "cmp").should be_nil
(Complex(1) <=> "cmp").should be_nil
(Complex(1) <=> Object.new).should be_nil
end
it "returns nil if argument is not numeric" do
(Complex(5, 1) <=> "cmp").should be_nil
(Complex(1) <=> "cmp").should be_nil
(Complex(1) <=> Object.new).should be_nil
end
it "returns 0, 1, or -1 if self and argument do not have imaginary part" do
(Complex(5) <=> Complex(2)).should == 1
(Complex(2) <=> Complex(3)).should == -1
(Complex(2) <=> Complex(2)).should == 0
it "returns 0, 1, or -1 if self and argument do not have imaginary part" do
(Complex(5) <=> Complex(2)).should == 1
(Complex(2) <=> Complex(3)).should == -1
(Complex(2) <=> Complex(2)).should == 0
(Complex(5) <=> 2).should == 1
(Complex(2) <=> 3).should == -1
(Complex(2) <=> 2).should == 0
end
(Complex(5) <=> 2).should == 1
(Complex(2) <=> 3).should == -1
(Complex(2) <=> 2).should == 0
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)

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

@ -23,19 +23,8 @@ 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
it "raises an ArgumentError if the string contains \\0" do
-> {Dir.send(@method, "file_o*\0file_t*")}.should raise_error ArgumentError, /nul-separated/
end
ruby_version_is "3.0" do

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

@ -40,10 +40,8 @@ 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
it 'includes CESU-8 encoding' do
Encoding.list.should.include?(Encoding::CESU_8)
end
# TODO: Find example that illustrates this

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

@ -1,26 +1,24 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is '2.7' do
describe 'Enumerable#filter_map' do
before :each do
@numerous = EnumerableSpecs::Numerous.new(*(1..8).to_a)
end
describe 'Enumerable#filter_map' do
before :each do
@numerous = EnumerableSpecs::Numerous.new(*(1..8).to_a)
end
it 'returns an empty array if there are no elements' do
EnumerableSpecs::Empty.new.filter_map { true }.should == []
end
it 'returns an empty array if there are no elements' do
EnumerableSpecs::Empty.new.filter_map { true }.should == []
end
it 'returns an array with truthy results of passing each element to block' do
@numerous.filter_map { |i| i * 2 if i.even? }.should == [4, 8, 12, 16]
@numerous.filter_map { |i| i * 2 }.should == [2, 4, 6, 8, 10, 12, 14, 16]
@numerous.filter_map { 0 }.should == [0, 0, 0, 0, 0, 0, 0, 0]
@numerous.filter_map { false }.should == []
@numerous.filter_map { nil }.should == []
end
it 'returns an array with truthy results of passing each element to block' do
@numerous.filter_map { |i| i * 2 if i.even? }.should == [4, 8, 12, 16]
@numerous.filter_map { |i| i * 2 }.should == [2, 4, 6, 8, 10, 12, 14, 16]
@numerous.filter_map { 0 }.should == [0, 0, 0, 0, 0, 0, 0, 0]
@numerous.filter_map { false }.should == []
@numerous.filter_map { nil }.should == []
end
it 'returns an enumerator when no block given' do
@numerous.filter_map.should be_an_instance_of(Enumerator)
end
it 'returns an enumerator when no block given' do
@numerous.filter_map.should be_an_instance_of(Enumerator)
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

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

@ -1,36 +1,34 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" do
describe "Enumerable#tally" do
before :each do
ScratchPad.record []
end
describe "Enumerable#tally" do
before :each do
ScratchPad.record []
end
it "returns a hash with counts according to the value" do
enum = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz')
enum.tally.should == { 'foo' => 2, 'bar' => 1, 'baz' => 1}
end
it "returns a hash with counts according to the value" do
enum = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz')
enum.tally.should == { 'foo' => 2, 'bar' => 1, 'baz' => 1}
end
it "returns a hash without default" do
hash = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz').tally
hash.default_proc.should be_nil
hash.default.should be_nil
end
it "returns a hash without default" do
hash = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz').tally
hash.default_proc.should be_nil
hash.default.should be_nil
end
it "returns an empty hash for empty enumerables" do
EnumerableSpecs::Empty.new.tally.should == {}
end
it "returns an empty hash for empty enumerables" do
EnumerableSpecs::Empty.new.tally.should == {}
end
it "counts values as gathered array when yielded with multiple arguments" do
EnumerableSpecs::YieldsMixed2.new.tally.should == EnumerableSpecs::YieldsMixed2.gathered_yields.group_by(&:itself).transform_values(&:size)
end
it "counts values as gathered array when yielded with multiple arguments" do
EnumerableSpecs::YieldsMixed2.new.tally.should == EnumerableSpecs::YieldsMixed2.gathered_yields.group_by(&:itself).transform_values(&:size)
end
it "does not call given block" do
enum = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz')
enum.tally { |v| ScratchPad << v }
ScratchPad.recorded.should == []
end
it "does not call given block" do
enum = EnumerableSpecs::Numerous.new('foo', 'bar', 'foo', 'baz')
enum.tally { |v| ScratchPad << v }
ScratchPad.recorded.should == []
end
end

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

@ -31,76 +31,32 @@ 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')
obj.should_receive(:hash).at_least(1).and_return(0)
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)
false
end
obj
def obj.eql?(o)
false
end
a.uniq.should == a
a = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
def obj.eql?(o)
true
end
obj
end
a.to_enum.uniq.size.should == 1
obj
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)
a.uniq.should == a
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 = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
obj
def obj.eql?(o)
true
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?
obj
end
a.to_enum.uniq.size.should == 1
end
context 'when yielded with multiple arguments' do

10
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
context "with beginless" do
it "returns nil as begin of the sequence" do
(..10).step(1).begin.should == nil
(...10).step(1).begin.should == nil
end
end
end

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

@ -1,29 +1,27 @@
require_relative '../../../spec_helper'
ruby_version_is "2.7" do
describe "Enumerator::Lazy#eager" do
it "returns a non-lazy Enumerator converted from the lazy enumerator" do
enum = [1, 2, 3].lazy
describe "Enumerator::Lazy#eager" do
it "returns a non-lazy Enumerator converted from the lazy enumerator" do
enum = [1, 2, 3].lazy
enum.class.should == Enumerator::Lazy
enum.eager.class.should == Enumerator
enum.class.should == Enumerator::Lazy
enum.eager.class.should == Enumerator
end
it "does not enumerate an enumerator" do
ScratchPad.record []
sequence = [1, 2, 3]
enum_lazy = Enumerator::Lazy.new(sequence) do |yielder, value|
yielder << value
ScratchPad << value
end
it "does not enumerate an enumerator" do
ScratchPad.record []
ScratchPad.recorded.should == []
enum = enum_lazy.eager
ScratchPad.recorded.should == []
sequence = [1, 2, 3]
enum_lazy = Enumerator::Lazy.new(sequence) do |yielder, value|
yielder << value
ScratchPad << value
end
ScratchPad.recorded.should == []
enum = enum_lazy.eager
ScratchPad.recorded.should == []
enum.map { |i| i }.should == [1, 2, 3]
ScratchPad.recorded.should == [1, 2, 3]
end
enum.map { |i| i }.should == [1, 2, 3]
ScratchPad.recorded.should == [1, 2, 3]
end
end

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

@ -3,14 +3,12 @@
require_relative '../../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" 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
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
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
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

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

@ -3,36 +3,34 @@
require_relative '../../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" 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
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
it "enumerates with an index starting at a given offset" do
(0..Float::INFINITY).lazy.with_index(3).map { |i, idx| [i, idx] }.first(3).should == [[0, 3], [1, 4], [2, 5]]
end
it "enumerates with an index starting at a given offset" do
(0..Float::INFINITY).lazy.with_index(3).map { |i, idx| [i, idx] }.first(3).should == [[0, 3], [1, 4], [2, 5]]
end
it "enumerates with an index starting at 0 when offset is nil" do
(0..Float::INFINITY).lazy.with_index(nil).map { |i, idx| [i, idx] }.first(3).should == [[0, 0], [1, 1], [2, 2]]
end
it "enumerates with an index starting at 0 when offset is nil" do
(0..Float::INFINITY).lazy.with_index(nil).map { |i, idx| [i, idx] }.first(3).should == [[0, 0], [1, 1], [2, 2]]
end
it "raises TypeError when offset does not convert to Integer" do
-> { (0..Float::INFINITY).lazy.with_index(false).map { |i, idx| i }.first(3) }.should raise_error(TypeError)
end
it "raises TypeError when offset does not convert to Integer" do
-> { (0..Float::INFINITY).lazy.with_index(false).map { |i, idx| i }.first(3) }.should raise_error(TypeError)
end
it "enumerates with a given block" do
result = []
(0..Float::INFINITY).lazy.with_index { |i, idx| result << [i * 2, idx] }.first(3)
result.should == [[0,0],[2,1],[4,2]]
end
it "enumerates with a given block" do
result = []
(0..Float::INFINITY).lazy.with_index { |i, idx| result << [i * 2, idx] }.first(3)
result.should == [[0,0],[2,1],[4,2]]
end
it "resets after a new call to each" do
enum = (0..2).lazy.with_index.map { |i, idx| [i, idx] }
result = []
enum.each { |i, idx| result << [i, idx] }
enum.each { |i, idx| result << [i, idx] }
result.should == [[0,0], [1,1], [2,2], [0,0], [1,1], [2,2]]
end
it "resets after a new call to each" do
enum = (0..2).lazy.with_index.map { |i, idx| [i, idx] }
result = []
enum.each { |i, idx| result << [i, idx] }
enum.each { |i, idx| result << [i, idx] }
result.should == [[0,0], [1,1], [2,2], [0,0], [1,1], [2,2]]
end
end

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

@ -77,14 +77,12 @@ 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)
end
enum.to_a.should == ["a\n", "b\n", "c"]
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)
end
enum.to_a.should == ["a\n", "b\n", "c"]
end
describe 'yielded values' do

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

@ -1,36 +1,34 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" 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]
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]
end
it "terminates iteration when block raises StopIteration exception" do
enum = Enumerator.produce(0) do | prev|
raise StopIteration if prev >= 2
prev + 1
end
it "terminates iteration when block raises StopIteration exception" do
enum = Enumerator.produce(0) do | prev|
raise StopIteration if prev >= 2
prev + 1
end
enum.to_a.should == [0, 1, 2]
end
enum.to_a.should == [0, 1, 2]
context "when initial value skipped" do
it "uses nil instead" do
ScratchPad.record []
enum = Enumerator.produce { |prev| ScratchPad << prev; (prev || 0) + 1 }
enum.take(3).should == [1, 2, 3]
ScratchPad.recorded.should == [nil, 1, 2]
end
context "when initial value skipped" do
it "uses nil instead" do
ScratchPad.record []
enum = Enumerator.produce { |prev| ScratchPad << prev; (prev || 0) + 1 }
it "starts enumerable from result of first block call" do
array = "a\nb\nc\nd".lines
lines = Enumerator.produce { array.shift }.take_while { |s| s }
enum.take(3).should == [1, 2, 3]
ScratchPad.recorded.should == [nil, 1, 2]
end
it "starts enumerable from result of first block call" do
array = "a\nb\nc\nd".lines
lines = Enumerator.produce { array.shift }.take_while { |s| s }
lines.should == ["a\n", "b\n", "c\n", "d"]
end
lines.should == ["a\n", "b\n", "c\n", "d"]
end
end
end

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

@ -1,18 +1,16 @@
require_relative '../../../spec_helper'
ruby_version_is "2.7" 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" }
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" }
callable = y.to_proc
callable.class.should == Proc
callable = y.to_proc
callable.class.should == Proc
result = callable.call(1, 2)
ScratchPad.recorded.should == [[1, 2]]
result = callable.call(1, 2)
ScratchPad.recorded.should == [[1, 2]]
result.should == "foobar"
end
result.should == "foobar"
end
end

6
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
it_behaves_like :env_update, :merge!
end
describe "ENV.merge!" do
it_behaves_like :env_update, :merge!
end

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

@ -39,23 +39,21 @@ 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")
ENV.send @method, {"foo" => "0"}
ENV.send(@method, "bar" => "1") { |key, old, new| fail "Should not get here" }
ENV["bar"].should == "1"
end
# BUG: https://bugs.ruby-lang.org/issues/16192
it "does not evaluate the block when the name is new" do
ENV.delete("bar")
ENV.send @method, {"foo" => "0"}
ENV.send(@method, "bar" => "1") { |key, old, new| fail "Should not get here" }
ENV["bar"].should == "1"
end
# BUG: https://bugs.ruby-lang.org/issues/16192
it "does not use the block's return value as the value when the name is new" do
ENV.delete("bar")
ENV.send @method, {"foo" => "0"}
ENV.send(@method, "bar" => "1") { |key, old, new| "Should not use this value" }
ENV["foo"].should == "0"
ENV["bar"].should == "1"
end
# BUG: https://bugs.ruby-lang.org/issues/16192
it "does not use the block's return value as the value when the name is new" do
ENV.delete("bar")
ENV.send @method, {"foo" => "0"}
ENV.send(@method, "bar" => "1") { |key, old, new| "Should not use this value" }
ENV["foo"].should == "0"
ENV["bar"].should == "1"
end
it "returns ENV when block given" do

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

@ -1,26 +1,22 @@
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
it "should take optional receiver argument" do
o = Object.new
FrozenError.new("msg", receiver: o).receiver.should equal(o)
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
def o.x; end
rescue => e
e.should be_kind_of(FrozenError)
e.receiver.should equal(o)
else
raise
end
it "should return frozen object that modification was attempted on" do
o = Object.new.freeze
begin
def o.x; end
rescue => e
e.should be_kind_of(FrozenError)
e.receiver.should equal(o)
else
raise
end
end
end

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

@ -5,13 +5,11 @@ 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
it "returns a frozen string" do
false.to_s.should.frozen?
end
it "always returns the same string" do
false.to_s.should equal(false.to_s)
end
it "always returns the same string" do
false.to_s.should equal(false.to_s)
end
end

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

@ -2,101 +2,99 @@ require_relative '../../spec_helper'
require_relative 'fixtures/classes'
require_relative '../../shared/kernel/raise'
ruby_version_is "2.7" do
describe "Fiber#raise" do
it_behaves_like :kernel_raise, :raise, FiberSpecs::NewFiberToRaise
end
describe "Fiber#raise" do
it 'raises RuntimeError by default' do
-> { FiberSpecs::NewFiberToRaise.raise }.should raise_error(RuntimeError)
end
it "raises FiberError if Fiber is not born" do
fiber = Fiber.new { true }
-> { fiber.raise }.should raise_error(FiberError, "cannot raise exception on unborn fiber")
end
it "raises FiberError if Fiber is dead" do
fiber = Fiber.new { true }
fiber.resume
-> { fiber.raise }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
end
it 'accepts error class' do
-> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError }.should raise_error(FiberSpecs::CustomError)
end
it 'accepts error message' do
-> { FiberSpecs::NewFiberToRaise.raise "error message" }.should raise_error(RuntimeError, "error message")
end
it 'does not accept array of backtrace information only' do
-> { FiberSpecs::NewFiberToRaise.raise ['foo'] }.should raise_error(TypeError)
end
it 'does not accept integer' do
-> { FiberSpecs::NewFiberToRaise.raise 100 }.should raise_error(TypeError)
end
it 'accepts error class with error message' do
-> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error' }.should raise_error(FiberSpecs::CustomError, 'test error')
end
it 'accepts error class with with error message and backtrace information' do
-> {
FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error', ['foo', 'boo']
}.should raise_error(FiberSpecs::CustomError) { |e|
e.message.should == 'test error'
e.backtrace.should == ['foo', 'boo']
}
end
it 'does not accept only error message and backtrace information' do
-> { FiberSpecs::NewFiberToRaise.raise 'test error', ['foo', 'boo'] }.should raise_error(TypeError)
end
it "raises a FiberError if invoked from a different Thread" do
fiber = Fiber.new { Fiber.yield }
fiber.resume
Thread.new do
-> {
fiber.raise
}.should raise_error(FiberError, "fiber called across threads")
end.join
end
it "kills Fiber" do
fiber = Fiber.new { Fiber.yield :first; :second }
fiber.resume
-> { fiber.raise }.should raise_error
-> { fiber.resume }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
end
it "returns to calling fiber after raise" do
fiber_one = Fiber.new do
Fiber.yield :yield_one
:unreachable
end
fiber_two = Fiber.new do
results = []
results << fiber_one.resume
begin
fiber_one.raise
rescue
results << :rescued
end
results
end
fiber_two.resume.should == [:yield_one, :rescued]
end
end
describe "Fiber#raise" do
it_behaves_like :kernel_raise, :raise, FiberSpecs::NewFiberToRaise
end
ruby_version_is "2.7"..."3.0" do
describe "Fiber#raise" do
it 'raises RuntimeError by default' do
-> { FiberSpecs::NewFiberToRaise.raise }.should raise_error(RuntimeError)
end
it "raises FiberError if Fiber is not born" do
fiber = Fiber.new { true }
-> { fiber.raise }.should raise_error(FiberError, "cannot raise exception on unborn fiber")
end
it "raises FiberError if Fiber is dead" do
fiber = Fiber.new { true }
fiber.resume
-> { fiber.raise }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
end
it 'accepts error class' do
-> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError }.should raise_error(FiberSpecs::CustomError)
end
it 'accepts error message' do
-> { FiberSpecs::NewFiberToRaise.raise "error message" }.should raise_error(RuntimeError, "error message")
end
it 'does not accept array of backtrace information only' do
-> { FiberSpecs::NewFiberToRaise.raise ['foo'] }.should raise_error(TypeError)
end
it 'does not accept integer' do
-> { FiberSpecs::NewFiberToRaise.raise 100 }.should raise_error(TypeError)
end
it 'accepts error class with error message' do
-> { FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error' }.should raise_error(FiberSpecs::CustomError, 'test error')
end
it 'accepts error class with with error message and backtrace information' do
-> {
FiberSpecs::NewFiberToRaise.raise FiberSpecs::CustomError, 'test error', ['foo', 'boo']
}.should raise_error(FiberSpecs::CustomError) { |e|
e.message.should == 'test error'
e.backtrace.should == ['foo', 'boo']
}
end
it 'does not accept only error message and backtrace information' do
-> { FiberSpecs::NewFiberToRaise.raise 'test error', ['foo', 'boo'] }.should raise_error(TypeError)
end
it "raises a FiberError if invoked from a different Thread" do
fiber = Fiber.new { Fiber.yield }
fiber.resume
Thread.new do
-> {
fiber.raise
}.should raise_error(FiberError, "fiber called across threads")
end.join
end
it "kills Fiber" do
fiber = Fiber.new { Fiber.yield :first; :second }
fiber.resume
-> { fiber.raise }.should raise_error
-> { fiber.resume }.should raise_error(FiberError, /dead fiber called|attempt to resume a terminated fiber/)
end
it "returns to calling fiber after raise" do
fiber_one = Fiber.new do
Fiber.yield :yield_one
:unreachable
end
fiber_two = Fiber.new do
results = []
results << fiber_one.resume
begin
fiber_one.raise
rescue
results << :rescued
end
results
end
fiber_two.resume.should == [:yield_one, :rescued]
end
end
ruby_version_is ""..."3.0" do
describe "Fiber#raise" do
it "raises a FiberError if invoked on a transferring Fiber" do
require "fiber"

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

@ -1,54 +1,52 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" do
describe "File.absolute_path?" do
before :each do
@abs = File.expand_path(__FILE__)
describe "File.absolute_path?" do
before :each do
@abs = File.expand_path(__FILE__)
end
it "returns true if it's an absolute pathname" do
File.absolute_path?(@abs).should be_true
end
it "returns false if it's a relative path" do
File.absolute_path?(File.basename(__FILE__)).should be_false
end
it "returns false if it's a tricky relative path" do
File.absolute_path?("C:foo\\bar").should be_false
end
it "does not expand '~' to a home directory." do
File.absolute_path?('~').should be_false
end
it "does not expand '~user' to a home directory." do
path = File.dirname(@abs)
Dir.chdir(path) do
File.absolute_path?('~user').should be_false
end
end
it "returns true if it's an absolute pathname" do
File.absolute_path?(@abs).should be_true
it "calls #to_path on its argument" do
mock = mock_to_path(File.expand_path(__FILE__))
File.absolute_path?(mock).should be_true
end
platform_is_not :windows do
it "takes into consideration the platform's root" do
File.absolute_path?("C:\\foo\\bar").should be_false
File.absolute_path?("C:/foo/bar").should be_false
File.absolute_path?("/foo/bar\\baz").should be_true
end
end
it "returns false if it's a relative path" do
File.absolute_path?(File.basename(__FILE__)).should be_false
end
it "returns false if it's a tricky relative path" do
File.absolute_path?("C:foo\\bar").should be_false
end
it "does not expand '~' to a home directory." do
File.absolute_path?('~').should be_false
end
it "does not expand '~user' to a home directory." do
path = File.dirname(@abs)
Dir.chdir(path) do
File.absolute_path?('~user').should be_false
end
end
it "calls #to_path on its argument" do
mock = mock_to_path(File.expand_path(__FILE__))
File.absolute_path?(mock).should be_true
end
platform_is_not :windows do
it "takes into consideration the platform's root" do
File.absolute_path?("C:\\foo\\bar").should be_false
File.absolute_path?("C:/foo/bar").should be_false
File.absolute_path?("/foo/bar\\baz").should be_true
end
end
platform_is :windows do
it "takes into consideration the platform path separator(s)" do
File.absolute_path?("C:\\foo\\bar").should be_true
File.absolute_path?("C:/foo/bar").should be_true
File.absolute_path?("/foo/bar\\baz").should be_false
end
platform_is :windows do
it "takes into consideration the platform path separator(s)" do
File.absolute_path?("C:\\foo\\bar").should be_true
File.absolute_path?("C:/foo/bar").should be_true
File.absolute_path?("/foo/bar\\baz").should be_false
end
end
end

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 == "."

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

@ -42,26 +42,13 @@ 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 == {}
}.should raise_error(ArgumentError)
-> {
Hash[[:nil]].should == {}
}.should raise_error(ArgumentError)
end
it "raises for elements that are not arrays" do
-> {
Hash[[:a]].should == {}
}.should raise_error(ArgumentError)
-> {
Hash[[:nil]].should == {}
}.should raise_error(ArgumentError)
end
it "raises an ArgumentError for arrays of more than 2 elements" do

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

@ -1,25 +1,23 @@
require_relative '../../spec_helper'
ruby_version_is "2.7" do
describe "Hash#deconstruct_keys" do
it "returns self" do
hash = {a: 1, b: 2}
describe "Hash#deconstruct_keys" do
it "returns self" do
hash = {a: 1, b: 2}
hash.deconstruct_keys([:a, :b]).should equal hash
end
hash.deconstruct_keys([:a, :b]).should equal hash
end
it "requires one argument" do
-> {
{a: 1}.deconstruct_keys
}.should raise_error(ArgumentError, /wrong number of arguments \(given 0, expected 1\)/)
end
it "requires one argument" do
-> {
{a: 1}.deconstruct_keys
}.should raise_error(ArgumentError, /wrong number of arguments \(given 0, expected 1\)/)
end
it "ignores argument" do
hash = {a: 1, b: 2}
it "ignores argument" do
hash = {a: 1, b: 2}
hash.deconstruct_keys([:a]).should == {a: 1, b: 2}
hash.deconstruct_keys(0 ).should == {a: 1, b: 2}
hash.deconstruct_keys('' ).should == {a: 1, b: 2}
end
hash.deconstruct_keys([:a]).should == {a: 1, b: 2}
hash.deconstruct_keys(0 ).should == {a: 1, b: 2}
hash.deconstruct_keys('' ).should == {a: 1, b: 2}
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

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

@ -1,61 +1,59 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.7" 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
it "returns true if the Hash is a keywords Hash marked by Module#ruby2_keywords" do
obj = Class.new {
ruby2_keywords def m(*args)
args.last
end
}.new
Hash.ruby2_keywords_hash?(obj.m(a: 1)).should == true
end
it "raises TypeError for non-Hash" do
-> { Hash.ruby2_keywords_hash?(nil) }.should raise_error(TypeError)
end
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
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)
Hash.ruby2_keywords_hash?(h).should == false
Hash.ruby2_keywords_hash?(kw).should == true
kw.should == h
end
it "returns true if the Hash is a keywords Hash marked by Module#ruby2_keywords" do
obj = Class.new {
ruby2_keywords def m(*args)
args.last
end
}.new
Hash.ruby2_keywords_hash?(obj.m(a: 1)).should == true
end
it "returns an instance of the subclass if called on an instance of a subclass of Hash" do
h = HashSpecs::MyHash.new
h[:a] = 1
kw = Hash.ruby2_keywords_hash(h)
kw.class.should == HashSpecs::MyHash
Hash.ruby2_keywords_hash?(h).should == false
Hash.ruby2_keywords_hash?(kw).should == true
kw.should == h
end
it "copies instance variables" do
h = {a: 1}
h.instance_variable_set(:@foo, 42)
kw = Hash.ruby2_keywords_hash(h)
kw.instance_variable_get(:@foo).should == 42
end
it "copies the hash internals" do
h = {a: 1}
kw = Hash.ruby2_keywords_hash(h)
h[:a] = 2
kw[:a].should == 1
end
it "raises TypeError for non-Hash" do
-> { Hash.ruby2_keywords_hash(nil) }.should raise_error(TypeError)
end
it "raises TypeError for non-Hash" do
-> { Hash.ruby2_keywords_hash?(nil) }.should raise_error(TypeError)
end
end
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)
Hash.ruby2_keywords_hash?(h).should == false
Hash.ruby2_keywords_hash?(kw).should == true
kw.should == h
end
it "returns an instance of the subclass if called on an instance of a subclass of Hash" do
h = HashSpecs::MyHash.new
h[:a] = 1
kw = Hash.ruby2_keywords_hash(h)
kw.class.should == HashSpecs::MyHash
Hash.ruby2_keywords_hash?(h).should == false
Hash.ruby2_keywords_hash?(kw).should == true
kw.should == h
end
it "copies instance variables" do
h = {a: 1}
h.instance_variable_set(:@foo, 42)
kw = Hash.ruby2_keywords_hash(h)
kw.instance_variable_get(:@foo).should == 42
end
it "copies the hash internals" do
h = {a: 1}
kw = Hash.ruby2_keywords_hash(h)
h[:a] = 2
kw[:a].should == 1
end
it "raises TypeError for non-Hash" do
-> { Hash.ruby2_keywords_hash(nil) }.should raise_error(TypeError)
end
end

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

@ -149,80 +149,34 @@ 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
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
# 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)
def obj.eql?(o)
return true if self.equal?(o)
false
end
obj
def obj.eql?(o)
return true if self.equal?(o)
false
end
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_false
a = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
def obj.eql?(o)
true
end
obj
end
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_true
obj
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)
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_false
# 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
a = Array.new(2) do
obj = mock('0')
obj.should_receive(:hash).at_least(1).and_return(0)
obj
def obj.eql?(o)
true
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
obj
end
{ a[0] => 1 }.send(@method, { a[1] => 1 }).should be_true
end
it "compares the values in self to values in other hash" do

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

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

@ -245,16 +245,14 @@ 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
0x0045.chr(Encoding::CESU_8).bytes.should == 0x0045.chr(Encoding::UTF_8).bytes
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
0x0045.chr(Encoding::CESU_8).bytes.should == 0x0045.chr(Encoding::UTF_8).bytes
# code points in range from U+10000 to U+10FFFF is CESU-8 data containing a 6-byte surrogate pair,
# which decodes to a 4-byte UTF-8 string
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
# code points in range from U+10000 to U+10FFFF is CESU-8 data containing a 6-byte surrogate pair,
# which decodes to a 4-byte UTF-8 string
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

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

@ -79,81 +79,79 @@ 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
0b101001101[2, 5].should == 0b10011
0b101001101[2, 7].should == 0b1010011
end
it "ensures n[i, len] equals to (n >> i) & ((1 << len) - 1)" do
n = 0b101001101; i = 2; len = 4
n[i, len].should == (n >> i) & ((1 << len) - 1)
end
it "moves start position to the most significant bits when negative index passed" do
0b000001[-1, 4].should == 0b10
0b000001[-2, 4].should == 0b100
0b000001[-3, 4].should == 0b1000
end
it "ignores negative length" do
0b101001101[1, -1].should == 0b10100110
0b101001101[2, -1].should == 0b1010011
0b101001101[3, -1].should == 0b101001
0b101001101[3, -5].should == 0b101001
0b101001101[3, -15].should == 0b101001
0b101001101[3, -125].should == 0b101001
end
context "when index and length passed" do
it "returns specified number of bits from specified position" do
0b101001101[2, 4].should == 0b0011
0b101001101[2, 5].should == 0b10011
0b101001101[2, 7].should == 0b1010011
end
context "when range passed" do
it "returns bits specified by range" do
0b101001101[2..5].should == 0b0011
0b101001101[2..6].should == 0b10011
0b101001101[2..8].should == 0b1010011
it "ensures n[i, len] equals to (n >> i) & ((1 << len) - 1)" do
n = 0b101001101; i = 2; len = 4
n[i, len].should == (n >> i) & ((1 << len) - 1)
end
it "moves start position to the most significant bits when negative index passed" do
0b000001[-1, 4].should == 0b10
0b000001[-2, 4].should == 0b100
0b000001[-3, 4].should == 0b1000
end
it "ignores negative length" do
0b101001101[1, -1].should == 0b10100110
0b101001101[2, -1].should == 0b1010011
0b101001101[3, -1].should == 0b101001
0b101001101[3, -5].should == 0b101001
0b101001101[3, -15].should == 0b101001
0b101001101[3, -125].should == 0b101001
end
end
context "when range passed" do
it "returns bits specified by range" do
0b101001101[2..5].should == 0b0011
0b101001101[2..6].should == 0b10011
0b101001101[2..8].should == 0b1010011
end
it "ensures n[i..j] equals to (n >> i) & ((1 << (j - i + 1)) - 1)" do
n = 0b101001101; i = 2; j = 5
n[i..j].should == (n >> i) & ((1 << (j - i + 1)) - 1)
end
it "ensures n[i..] equals to (n >> i)" do
eval("0b101001101[3..]").should == 0b101001101 >> 3
end
it "moves lower boundary to the most significant bits when negative value passed" do
0b000001[-1, 4].should == 0b10
0b000001[-2, 4].should == 0b100
0b000001[-3, 4].should == 0b1000
end
it "ignores upper boundary smaller than lower boundary" do
0b101001101[4..1].should == 0b10100
0b101001101[4..2].should == 0b10100
0b101001101[-4..-5].should == 0b1010011010000
end
it "raises FloatDomainError if any boundary is infinity" do
-> { 0x0001[3..Float::INFINITY] }.should raise_error(FloatDomainError, /Infinity/)
-> { 0x0001[-Float::INFINITY..3] }.should raise_error(FloatDomainError, /-Infinity/)
end
context "when passed (..i)" do
it "returns 0 if all i bits equal 0" do
eval("0b10000[..1]").should == 0
eval("0b10000[..2]").should == 0
eval("0b10000[..3]").should == 0
end
it "ensures n[i..j] equals to (n >> i) & ((1 << (j - i + 1)) - 1)" do
n = 0b101001101; i = 2; j = 5
n[i..j].should == (n >> i) & ((1 << (j - i + 1)) - 1)
end
it "ensures n[i..] equals to (n >> i)" do
eval("0b101001101[3..]").should == 0b101001101 >> 3
end
it "moves lower boundary to the most significant bits when negative value passed" do
0b000001[-1, 4].should == 0b10
0b000001[-2, 4].should == 0b100
0b000001[-3, 4].should == 0b1000
end
it "ignores upper boundary smaller than lower boundary" do
0b101001101[4..1].should == 0b10100
0b101001101[4..2].should == 0b10100
0b101001101[-4..-5].should == 0b1010011010000
end
it "raises FloatDomainError if any boundary is infinity" do
-> { 0x0001[3..Float::INFINITY] }.should raise_error(FloatDomainError, /Infinity/)
-> { 0x0001[-Float::INFINITY..3] }.should raise_error(FloatDomainError, /-Infinity/)
end
context "when passed (..i)" do
it "returns 0 if all i bits equal 0" do
eval("0b10000[..1]").should == 0
eval("0b10000[..2]").should == 0
eval("0b10000[..3]").should == 0
end
it "raises ArgumentError if any of i bit equals 1" do
-> {
eval("0b111110[..3]")
}.should raise_error(ArgumentError, /The beginless range for Integer#\[\] results in infinity/)
end
it "raises ArgumentError if any of i bit equals 1" do
-> {
eval("0b111110[..3]")
}.should raise_error(ArgumentError, /The beginless range for Integer#\[\] results in infinity/)
end
end
end

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

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

@ -12,66 +12,64 @@ 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")
it "returns the result encoding if found BOM UTF-8 sequence" do
File.binwrite(@name, "\u{FEFF}abc")
@io.set_encoding_by_bom.should == Encoding::UTF_8
@io.external_encoding.should == Encoding::UTF_8
end
@io.set_encoding_by_bom.should == Encoding::UTF_8
@io.external_encoding.should == Encoding::UTF_8
end
it "returns the result encoding if found BOM UTF_16LE sequence" do
File.binwrite(@name, "\xFF\xFEabc")
it "returns the result encoding if found BOM UTF_16LE sequence" do
File.binwrite(@name, "\xFF\xFEabc")
@io.set_encoding_by_bom.should == Encoding::UTF_16LE
@io.external_encoding.should == Encoding::UTF_16LE
end
@io.set_encoding_by_bom.should == Encoding::UTF_16LE
@io.external_encoding.should == Encoding::UTF_16LE
end
it "returns the result encoding if found BOM UTF_16BE sequence" do
File.binwrite(@name, "\xFE\xFFabc")
it "returns the result encoding if found BOM UTF_16BE sequence" do
File.binwrite(@name, "\xFE\xFFabc")
@io.set_encoding_by_bom.should == Encoding::UTF_16BE
@io.external_encoding.should == Encoding::UTF_16BE
end
@io.set_encoding_by_bom.should == Encoding::UTF_16BE
@io.external_encoding.should == Encoding::UTF_16BE
end
it "returns the result encoding if found BOM UTF_32LE sequence" do
File.binwrite(@name, "\xFF\xFE\x00\x00abc")
it "returns the result encoding if found BOM UTF_32LE sequence" do
File.binwrite(@name, "\xFF\xFE\x00\x00abc")
@io.set_encoding_by_bom.should == Encoding::UTF_32LE
@io.external_encoding.should == Encoding::UTF_32LE
end
@io.set_encoding_by_bom.should == Encoding::UTF_32LE
@io.external_encoding.should == Encoding::UTF_32LE
end
it "returns the result encoding if found BOM UTF_32BE sequence" do
File.binwrite(@name, "\x00\x00\xFE\xFFabc")
it "returns the result encoding if found BOM UTF_32BE sequence" do
File.binwrite(@name, "\x00\x00\xFE\xFFabc")
@io.set_encoding_by_bom.should == Encoding::UTF_32BE
@io.external_encoding.should == Encoding::UTF_32BE
end
@io.set_encoding_by_bom.should == Encoding::UTF_32BE
@io.external_encoding.should == Encoding::UTF_32BE
end
it "returns nil if found BOM sequence not provided" do
File.write(@name, "abc")
it "returns nil if found BOM sequence not provided" do
File.write(@name, "abc")
@io.set_encoding_by_bom.should == nil
end
@io.set_encoding_by_bom.should == nil
end
it 'returns exception if io not in binary mode' do
not_binary_io = new_io(@name, 'r')
it 'returns exception if io not in binary mode' do
not_binary_io = new_io(@name, 'r')
-> { not_binary_io.set_encoding_by_bom }.should raise_error(ArgumentError, 'ASCII incompatible encoding needs binmode')
ensure
not_binary_io.close
end
-> { not_binary_io.set_encoding_by_bom }.should raise_error(ArgumentError, 'ASCII incompatible encoding needs binmode')
ensure
not_binary_io.close
end
it 'returns exception if encoding already set' do
@io.set_encoding("utf-8")
it 'returns exception if encoding already set' do
@io.set_encoding("utf-8")
-> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding is set to UTF-8 already')
end
-> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding is set to UTF-8 already')
end
it 'returns exception if encoding conversion is already set' do
@io.set_encoding(Encoding::UTF_8, Encoding::UTF_16BE)
it 'returns exception if encoding conversion is already set' do
@io.set_encoding(Encoding::UTF_8, Encoding::UTF_16BE)
-> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding conversion is set')
end
-> { @io.set_encoding_by_bom }.should raise_error(ArgumentError, 'encoding conversion is set')
end
end

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

@ -36,20 +36,10 @@ 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
it "never raises RangeError" do
for i in [4095, 0x4f7574206f6620636861722072616e67ff] do
@io.ungetbyte(i).should be_nil
@io.getbyte.should == 255
end
end

10
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
it "works with beginless ranges" do
locations1 = caller_locations(0)
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

10
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
it "works with beginless ranges" do
locations1 = KernelSpecs::CallerTest.locations(0)
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

6
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
provided << 'ruby2_keywords'
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?

10
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
it "is the same as Object.ruby2_keywords" do
main = TOPLEVEL_BINDING.receiver
main.should have_private_method(:ruby2_keywords)
end
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

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

8
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
it "is undefined" do
# https://bugs.ruby-lang.org/issues/16294
-> { MatchData.allocate }.should raise_error(NoMethodError)
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)

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

@ -24,19 +24,17 @@ 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?("()")
obj.method(:one_req).send(@method).should.include?("(a)")
obj.method(:one_req_named).send(@method).should.include?("(a:)")
obj.method(:zero_with_block).send(@method).should.include?("(&blk)")
obj.method(:one_opt).send(@method).should.include?("(a=...)")
obj.method(:one_opt_named).send(@method).should.include?("(a: ...)")
obj.method(:zero_with_splat).send(@method).should.include?("(*a)")
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
it "returns a String containing method arguments" do
obj = MethodSpecs::Methods.new
obj.method(:zero).send(@method).should.include?("()")
obj.method(:one_req).send(@method).should.include?("(a)")
obj.method(:one_req_named).send(@method).should.include?("(a:)")
obj.method(:zero_with_block).send(@method).should.include?("(&blk)")
obj.method(:one_opt).send(@method).should.include?("(a=...)")
obj.method(:one_opt_named).send(@method).should.include?("(a: ...)")
obj.method(:zero_with_splat).send(@method).should.include?("(*a)")
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
it "returns a String containing the Module the method is defined in" do
@ -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
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
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

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

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

@ -18,16 +18,14 @@ 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
end
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
end
it "returns the name of the file that will be loaded if recursion is disabled but the autoload is defined on the class itself" do
ModuleSpecs::Autoload::Child.autoload :ChildAutoload, "child_autoload.rb"
ModuleSpecs::Autoload::Child.autoload?(:ChildAutoload, false).should == "child_autoload.rb"
end
it "returns the name of the file that will be loaded if recursion is disabled but the autoload is defined on the class itself" do
ModuleSpecs::Autoload::Child.autoload :ChildAutoload, "child_autoload.rb"
ModuleSpecs::Autoload::Child.autoload?(:ChildAutoload, false).should == "child_autoload.rb"
end
end
@ -514,9 +512,7 @@ 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
ModuleSpecs::Autoload.const_defined?("P").should be_true
end
it "loads the file when opening a module that is the autoloaded constant" do

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