github
/
ruby
зеркало из https://github.com/github/ruby.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Update to ruby/spec@15c9619

This commit is contained in:
Benoit Daloze 2019-04-27 18:53:23 +02:00
Родитель 00c33d9c23
Коммит a1b4816759
193 изменённых файлов: 3026 добавлений и 3387 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

20
spec/ruby/.travis.yml
Просмотреть файл

@ -3,20 +3,18 @@ language: ruby
install:
- git clone https://github.com/ruby/mspec.git ../mspec
script:
- ../mspec/bin/mspec $MSPEC_OPTS
- CHECK_LEAKS=true ../mspec/bin/mspec
matrix:
include:
- name: Running each spec twice
rvm: 2.5.5
script:
- CHECK_LEAKS=true ../mspec/bin/mspec -R2 -ff
- rvm: 2.4.6
- rvm: 2.5.5
env: MSPEC_OPTS="-R2 -ff"
- rvm: 2.3.8
- rvm: 2.4.5
env: CHECK_LEAKS=true
- rvm: 2.5.5
env: CHECK_LEAKS=true
- rvm: 2.6.2
env: CHECK_LEAKS=true
- env: RUBOCOP=true
rvm: 2.4.5
- rvm: 2.6.3
- name: RuboCop Lint Checks
rvm: 2.4.6
script:
- gem install rubocop:0.61.0
- rubocop

14
spec/ruby/CONTRIBUTING.md
Просмотреть файл

@ -144,11 +144,11 @@ end
# Combining guards
guard -> { platform_is :windows and ruby_version_is ""..."2.3" } do
# Windows and RUBY_VERSION < 2.3
guard -> { platform_is :windows and ruby_version_is ""..."2.5" } do
# Windows and RUBY_VERSION < 2.5
end
guard_not -> { platform_is :windows and ruby_version_is ""..."2.3" } do
guard_not -> { platform_is :windows and ruby_version_is ""..."2.5" } do
# The opposite
end
@ -170,20 +170,20 @@ If an implementation does not support some feature, simply tag the related specs
### Shared Specs
Often throughout Ruby, identical functionality is used by different methods and modules. In order
Often throughout Ruby, identical functionality is used by different methods and modules. In order
to avoid duplication of specs, we have shared specs that are re-used in other specs. The use is a
bit tricky however, so let's go over it.
Commonly, if a shared spec is only reused within its own module, the shared spec will live within a
shared directory inside that module's directory. For example, the `core/hash/shared/key.rb` spec is
shared directory inside that module's directory. For example, the `core/hash/shared/key.rb` spec is
only used by `Hash` specs, and so it lives inside `core/hash/shared/`.
When a shared spec is used across multiple modules or classes, it lives within the `shared/` directory.
An example of this is the `shared/file/socket.rb` which is used by `core/file/socket_spec.rb`,
An example of this is the `shared/file/socket.rb` which is used by `core/file/socket_spec.rb`,
`core/filetest/socket_spec.rb`, and `core/file/state/socket_spec.rb` and so it lives in the root `shared/`.
Defining a shared spec involves adding a `shared: true` option to the top-level `describe` block. This
will signal not to run the specs directly by the runner. Shared specs have access to two instance
will signal not to run the specs directly by the runner. Shared specs have access to two instance
variables from the implementor spec: `@method` and `@object`, which the implementor spec will pass in.
Here's an example of a snippet of a shared spec and two specs which integrates it:

5
spec/ruby/README.md
Просмотреть файл

@ -28,8 +28,8 @@ ruby/spec is known to be tested in these implementations for every commit:
* [TruffleRuby](https://github.com/oracle/truffleruby/tree/master/spec/ruby)
* [Opal](https://github.com/opal/opal/tree/master/spec)
ruby/spec describes the behavior of Ruby 2.3 and more recent Ruby versions.
More precisely, every latest stable MRI release should [pass](https://travis-ci.org/ruby/spec) all specs of ruby/spec (2.3.x, 2.4.x, 2.5.x, 2.6.x, etc), and those are tested in TravisCI.
ruby/spec describes the behavior of Ruby 2.4 and more recent Ruby versions.
More precisely, every latest stable MRI release should [pass](https://travis-ci.org/ruby/spec) all specs of ruby/spec (2.4.x, 2.5.x, 2.6.x, etc), and those are tested in TravisCI.
The specs are synchronized both ways around once a month by @eregon between ruby/spec, MRI, JRuby and TruffleRuby.
Each of these repositories has a full copy of the specs under `spec/ruby` to ease editing specs.
@ -49,6 +49,7 @@ For older specs try these commits:
* Ruby 2.0.0-p647 - [Suite](https://github.com/ruby/spec/commit/245862558761d5abc676843ef74f86c9bcc8ea8d) using [MSpec](https://github.com/ruby/mspec/commit/f90efa068791064f955de7a843e96e2d7d3041c2) (may encounter 2 failures)
* Ruby 2.1.9 - [Suite](https://github.com/ruby/spec/commit/f029e65241374386077ac500add557ae65069b55) using [MSpec](https://github.com/ruby/mspec/commit/55568ea3918c6380e64db8c567d732fa5781efed)
* Ruby 2.2.10 - [Suite](https://github.com/ruby/spec/commit/cbaa0e412270c944df0c2532fc500c920dba0e92) using [MSpec](https://github.com/ruby/mspec/commit/d84d7668449e96856c5f6bac8cb1526b6d357ce3)
* Ruby 2.3.8 - [Suite](https://github.com/ruby/spec/commit/dc733114d8ae66a3368ba3a98422c50147a76ba5) using [MSpec](https://github.com/ruby/mspec/commit/4599bc195fb109f2a482a01c32a7d659518369ea)
### Running the specs

9
spec/ruby/command_line/feature_spec.rb
Просмотреть файл

@ -37,15 +37,6 @@ describe "The --enable and --disable flags" do
ruby_exe("p 'foo'.frozen?", options: "--disable-frozen-string-literal").chomp.should == "false"
end
ruby_version_is "2.6" do
it "can be used with jit" do
ruby_exe("p :OK", options: "--enable=jit 2>&1").chomp.should == ":OK"
ruby_exe("p :OK", options: "--disable=jit 2>&1").chomp.should == ":OK"
ruby_exe("p :OK", options: "--enable-jit 2>&1").chomp.should == ":OK"
ruby_exe("p :OK", options: "--disable-jit 2>&1").chomp.should == ":OK"
end
end
it "can be used with all" do
e = "p [defined?(Gem), defined?(DidYouMean), $VERBOSE, 'foo'.frozen?]"
env = {'RUBYOPT' => '-w'}

30
spec/ruby/core/array/concat_spec.rb
Просмотреть файл

@ -110,23 +110,21 @@ describe "Array#concat" do
ary.concat([5, 6]).should == [4, 5, 6]
end
ruby_version_is "2.4" do
it "takes multiple arguments" do
ary = [1, 2]
ary.concat [3, 4]
ary.should == [1, 2, 3, 4]
end
it "takes multiple arguments" do
ary = [1, 2]
ary.concat [3, 4]
ary.should == [1, 2, 3, 4]
end
it "concatenates the initial value when given arguments contain 2 self" do
ary = [1, 2]
ary.concat ary, ary
ary.should == [1, 2, 1, 2, 1, 2]
end
it "concatenates the initial value when given arguments contain 2 self" do
ary = [1, 2]
ary.concat ary, ary
ary.should == [1, 2, 1, 2, 1, 2]
end
it "returns self when given no arguments" do
ary = [1, 2]
ary.concat.should equal(ary)
ary.should == [1, 2]
end
it "returns self when given no arguments" do
ary = [1, 2]
ary.concat.should equal(ary)
ary.should == [1, 2]
end
end

6
spec/ruby/core/array/max_spec.rb
Просмотреть файл

@ -1,10 +1,8 @@
require_relative '../../spec_helper'
describe "Array#max" do
ruby_version_is "2.4" do
it "is defined on Array" do
[1].method(:max).owner.should equal Array
end
it "is defined on Array" do
[1].method(:max).owner.should equal Array
end
it "returns nil with no values" do

6
spec/ruby/core/array/min_spec.rb
Просмотреть файл

@ -1,10 +1,8 @@
require_relative '../../spec_helper'
describe "Array#min" do
ruby_version_is "2.4" do
it "is defined on Array" do
[1].method(:max).owner.should equal Array
end
it "is defined on Array" do
[1].method(:max).owner.should equal Array
end
it "returns nil with no values" do

76
spec/ruby/core/array/pack/buffer_spec.rb
Просмотреть файл

@ -2,51 +2,49 @@
require_relative '../../../spec_helper'
ruby_version_is '2.4' do
describe "Array#pack with :buffer option" do
it "returns specified buffer" do
describe "Array#pack with :buffer option" do
it "returns specified buffer" do
n = [ 65, 66, 67 ]
buffer = " "*3
result = n.pack("ccc", buffer: buffer) #=> "ABC"
result.should equal(buffer)
end
it "adds result at the end of buffer content" do
n = [ 65, 66, 67 ] # result without buffer is "ABC"
buffer = ""
n.pack("ccc", buffer: buffer).should == "ABC"
buffer = "123"
n.pack("ccc", buffer: buffer).should == "123ABC"
buffer = "12345"
n.pack("ccc", buffer: buffer).should == "12345ABC"
end
it "raises TypeError exception if buffer is not String" do
lambda { [65].pack("ccc", buffer: []) }.should raise_error(
TypeError, "buffer must be String, not Array")
end
context "offset (@) is specified" do
it 'keeps buffer content if it is longer than offset' do
n = [ 65, 66, 67 ]
buffer = " "*3
result = n.pack("ccc", buffer: buffer) #=> "ABC"
result.should equal(buffer)
buffer = "123456"
n.pack("@3ccc", buffer: buffer).should == "123ABC"
end
it "adds result at the end of buffer content" do
n = [ 65, 66, 67 ] # result without buffer is "ABC"
buffer = ""
n.pack("ccc", buffer: buffer).should == "ABC"
it "fills the gap with \\0 if buffer content is shorter than offset" do
n = [ 65, 66, 67 ]
buffer = "123"
n.pack("ccc", buffer: buffer).should == "123ABC"
buffer = "12345"
n.pack("ccc", buffer: buffer).should == "12345ABC"
n.pack("@6ccc", buffer: buffer).should == "123\0\0\0ABC"
end
it "raises TypeError exception if buffer is not String" do
lambda { [65].pack("ccc", buffer: []) }.should raise_error(
TypeError, "buffer must be String, not Array")
end
context "offset (@) is specified" do
it 'keeps buffer content if it is longer than offset' do
n = [ 65, 66, 67 ]
buffer = "123456"
n.pack("@3ccc", buffer: buffer).should == "123ABC"
end
it "fills the gap with \\0 if buffer content is shorter than offset" do
n = [ 65, 66, 67 ]
buffer = "123"
n.pack("@6ccc", buffer: buffer).should == "123\0\0\0ABC"
end
it 'does not keep buffer content if it is longer than offset + result' do
n = [ 65, 66, 67 ]
buffer = "1234567890"
n.pack("@3ccc", buffer: buffer).should == "123ABC"
end
it 'does not keep buffer content if it is longer than offset + result' do
n = [ 65, 66, 67 ]
buffer = "1234567890"
n.pack("@3ccc", buffer: buffer).should == "123ABC"
end
end
end

24
spec/ruby/core/array/reject_spec.rb
Просмотреть файл

@ -121,22 +121,20 @@ describe "Array#reject!" do
a.should == [1, 2, 3]
end
ruby_version_is "2.4" do
it "only removes elements for which the block returns true, keeping the element which raised an error." do
a = [1, 2, 3, 4]
begin
a.reject! do |x|
case x
when 2 then true
when 3 then raise StandardError, 'Oops'
else false
end
it "only removes elements for which the block returns true, keeping the element which raised an error." do
a = [1, 2, 3, 4]
begin
a.reject! do |x|
case x
when 2 then true
when 3 then raise StandardError, 'Oops'
else false
end
rescue StandardError
end
a.should == [1, 3, 4]
rescue StandardError
end
a.should == [1, 3, 4]
end
it_behaves_like :enumeratorize, :reject!

62
spec/ruby/core/array/sum_spec.rb
Просмотреть файл

@ -1,44 +1,42 @@
require_relative '../../spec_helper'
ruby_version_is '2.4' do
describe "Array#sum" do
it "returns the sum of elements" do
[1, 2, 3].sum.should == 6
end
describe "Array#sum" do
it "returns the sum of elements" do
[1, 2, 3].sum.should == 6
end
it "applies a block to each element before adding if it's given" do
[1, 2, 3].sum { |i| i * 10 }.should == 60
end
it "applies a block to each element before adding if it's given" do
[1, 2, 3].sum { |i| i * 10 }.should == 60
end
it "returns init value if array is empty" do
[].sum(-1).should == -1
end
it "returns init value if array is empty" do
[].sum(-1).should == -1
end
it "returns 0 if array is empty and init is omitted" do
[].sum.should == 0
end
it "returns 0 if array is empty and init is omitted" do
[].sum.should == 0
end
it "adds init value to the sum of elements" do
[1, 2, 3].sum(10).should == 16
end
it "adds init value to the sum of elements" do
[1, 2, 3].sum(10).should == 16
end
it "can be used for non-numeric objects by providing init value" do
["a", "b", "c"].sum("").should == "abc"
end
it "can be used for non-numeric objects by providing init value" do
["a", "b", "c"].sum("").should == "abc"
end
it 'raises TypeError if any element are not numeric' do
lambda { ["a"].sum }.should raise_error(TypeError)
end
it 'raises TypeError if any element are not numeric' do
lambda { ["a"].sum }.should raise_error(TypeError)
end
it 'raises TypeError if any element cannot be added to init value' do
lambda { [1].sum([]) }.should raise_error(TypeError)
end
it 'raises TypeError if any element cannot be added to init value' do
lambda { [1].sum([]) }.should raise_error(TypeError)
end
it "calls + to sum the elements" do
a = mock("a")
b = mock("b")
a.should_receive(:+).with(b).and_return(42)
[b].sum(a).should == 42
end
it "calls + to sum the elements" do
a = mock("a")
b = mock("b")
a.should_receive(:+).with(b).and_return(42)
[b].sum(a).should == 42
end
end

6
spec/ruby/core/basicobject/basicobject_spec.rb
Просмотреть файл

@ -19,8 +19,12 @@ describe "BasicObject" do
BasicObjectSpecs::BOSubclass.kernel_defined?.should be_nil
end
it "is included in Object's list of constants" do
Object.constants(false).should include(:BasicObject)
end
it "includes itself in its list of constants" do
BasicObject.constants.should include(:BasicObject)
BasicObject.constants(false).should include(:BasicObject)
end
end

72
spec/ruby/core/comparable/clamp_spec.rb
Просмотреть файл

@ -1,50 +1,48 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is '2.4' do
describe 'Comparable#clamp' do
it 'raises an Argument error unless given 2 parameters' do
c = ComparableSpecs::Weird.new(0)
lambda { c.clamp(c) }.should raise_error(ArgumentError)
lambda { c.clamp(c, c, c) }.should raise_error(ArgumentError)
end
describe 'Comparable#clamp' do
it 'raises an Argument error unless given 2 parameters' do
c = ComparableSpecs::Weird.new(0)
lambda { c.clamp(c) }.should raise_error(ArgumentError)
lambda { c.clamp(c, c, c) }.should raise_error(ArgumentError)
end
it 'raises an Argument error unless the 2 parameters are correctly ordered' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
it 'raises an Argument error unless the 2 parameters are correctly ordered' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
lambda { c.clamp(two, one) }.should raise_error(ArgumentError)
one.should_receive(:<=>).any_number_of_times.and_return(nil)
lambda { c.clamp(one, two) }.should raise_error(ArgumentError)
end
lambda { c.clamp(two, one) }.should raise_error(ArgumentError)
one.should_receive(:<=>).any_number_of_times.and_return(nil)
lambda { c.clamp(one, two) }.should raise_error(ArgumentError)
end
it 'returns self if within the given parameters' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
three = ComparableSpecs::WithOnlyCompareDefined.new(3)
c = ComparableSpecs::Weird.new(2)
it 'returns self if within the given parameters' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
three = ComparableSpecs::WithOnlyCompareDefined.new(3)
c = ComparableSpecs::Weird.new(2)
c.clamp(one, two).should equal(c)
c.clamp(two, two).should equal(c)
c.clamp(one, three).should equal(c)
c.clamp(two, three).should equal(c)
end
c.clamp(one, two).should equal(c)
c.clamp(two, two).should equal(c)
c.clamp(one, three).should equal(c)
c.clamp(two, three).should equal(c)
end
it 'returns the min parameter if smaller than it' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(0)
it 'returns the min parameter if smaller than it' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(0)
c.clamp(one, two).should equal(one)
end
c.clamp(one, two).should equal(one)
end
it 'returns the max parameter if greater than it' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
it 'returns the max parameter if greater than it' do
one = ComparableSpecs::WithOnlyCompareDefined.new(1)
two = ComparableSpecs::WithOnlyCompareDefined.new(2)
c = ComparableSpecs::Weird.new(3)
c.clamp(one, two).should equal(two)
end
c.clamp(one, two).should equal(two)
end
end

50
spec/ruby/core/complex/finite_spec.rb
Просмотреть файл

@ -1,36 +1,32 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Complex#finite?" do
it "returns true if magnitude is finite" do
(1+1i).finite?.should == true
end
describe "Complex#finite?" do
it "returns true if magnitude is finite" do
(1+1i).finite?.should == true
end
it "returns false for positive infinity" do
value = Complex(Float::INFINITY, 42)
value.finite?.should == false
end
it "returns false for positive infinity" do
value = Complex(Float::INFINITY, 42)
value.finite?.should == false
end
it "returns false for positive complex with infinite imaginary" do
value = Complex(1, Float::INFINITY)
value.finite?.should == false
end
it "returns false for positive complex with infinite imaginary" do
value = Complex(1, Float::INFINITY)
value.finite?.should == false
end
it "returns false for negative infinity" do
value = -Complex(Float::INFINITY, 42)
value.finite?.should == false
end
it "returns false for negative infinity" do
value = -Complex(Float::INFINITY, 42)
value.finite?.should == false
end
it "returns false for negative complex with infinite imaginary" do
value = -Complex(1, Float::INFINITY)
value.finite?.should == false
end
it "returns false for negative complex with infinite imaginary" do
value = -Complex(1, Float::INFINITY)
value.finite?.should == false
end
ruby_bug "#14014", "2.4"..."2.5" do
it "returns false for NaN" do
value = Complex(Float::NAN, Float::NAN)
value.finite?.should == false
end
end
it "returns false for NaN" do
value = Complex(Float::NAN, Float::NAN)
value.finite?.should == false
end
end

48
spec/ruby/core/complex/infinite_spec.rb
Просмотреть файл

@ -1,34 +1,32 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Complex#infinite?" do
it "returns nil if magnitude is finite" do
(1+1i).infinite?.should == nil
end
describe "Complex#infinite?" do
it "returns nil if magnitude is finite" do
(1+1i).infinite?.should == nil
end
it "returns 1 for positive infinity" do
value = Complex(Float::INFINITY, 42).infinite?
value.should == 1
end
it "returns 1 for positive infinity" do
value = Complex(Float::INFINITY, 42).infinite?
value.should == 1
end
it "returns 1 for positive complex with infinite imaginary" do
value = Complex(1, Float::INFINITY).infinite?
value.should == 1
end
it "returns 1 for positive complex with infinite imaginary" do
value = Complex(1, Float::INFINITY).infinite?
value.should == 1
end
it "returns -1 for negative infinity" do
value = -Complex(Float::INFINITY, 42).infinite?
value.should == -1
end
it "returns -1 for negative infinity" do
value = -Complex(Float::INFINITY, 42).infinite?
value.should == -1
end
it "returns -1 for negative complex with infinite imaginary" do
value = -Complex(1, Float::INFINITY).infinite?
value.should == -1
end
it "returns -1 for negative complex with infinite imaginary" do
value = -Complex(1, Float::INFINITY).infinite?
value.should == -1
end
it "returns nil for NaN" do
value = Complex(0, Float::NAN).infinite?
value.should == nil
end
it "returns nil for NaN" do
value = Complex(0, Float::NAN).infinite?
value.should == nil
end
end

46
spec/ruby/core/dir/empty_spec.rb
Просмотреть файл

@ -1,33 +1,31 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Dir.empty?" do
before :all do
@empty_dir = tmp("empty_dir")
mkdir_p @empty_dir
end
describe "Dir.empty?" do
before :all do
@empty_dir = tmp("empty_dir")
mkdir_p @empty_dir
end
after :all do
rm_r @empty_dir
end
after :all do
rm_r @empty_dir
end
it "returns true for empty directories" do
result = Dir.empty? @empty_dir
result.should be_true
end
it "returns true for empty directories" do
result = Dir.empty? @empty_dir
result.should be_true
end
it "returns false for non-empty directories" do
result = Dir.empty? __dir__
result.should be_false
end
it "returns false for non-empty directories" do
result = Dir.empty? __dir__
result.should be_false
end
it "returns false for a non-directory" do
result = Dir.empty? __FILE__
result.should be_false
end
it "returns false for a non-directory" do
result = Dir.empty? __FILE__
result.should be_false
end
it "raises ENOENT for nonexistent directories" do
lambda { Dir.empty? tmp("nonexistent") }.should raise_error(Errno::ENOENT)
end
it "raises ENOENT for nonexistent directories" do
lambda { Dir.empty? tmp("nonexistent") }.should raise_error(Errno::ENOENT)
end
end

20
spec/ruby/core/enumerable/chunk_spec.rb
Просмотреть файл

@ -6,21 +6,11 @@ describe "Enumerable#chunk" do
ScratchPad.record []
end
ruby_version_is ""..."2.4" do
it "raises an ArgumentError if called without a block" do
lambda do
EnumerableSpecs::Numerous.new.chunk
end.should raise_error(ArgumentError)
end
end
ruby_version_is "2.4" do
it "returns an Enumerator if called without a block" do
chunk = EnumerableSpecs::Numerous.new(1, 2, 3, 1, 2).chunk
chunk.should be_an_instance_of(Enumerator)
result = chunk.with_index {|elt, i| elt - i }.to_a
result.should == [[1, [1, 2, 3]], [-2, [1, 2]]]
end
it "returns an Enumerator if called without a block" do
chunk = EnumerableSpecs::Numerous.new(1, 2, 3, 1, 2).chunk
chunk.should be_an_instance_of(Enumerator)
result = chunk.with_index {|elt, i| elt - i }.to_a
result.should == [[1, [1, 2, 3]], [-2, [1, 2]]]
end
it "returns an Enumerator if given a block" do

38
spec/ruby/core/enumerable/sum_spec.rb
Просмотреть файл

@ -1,30 +1,28 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is '2.4' do
describe 'Enumerable#sum' do
before :each do
@enum = Object.new.to_enum
class << @enum
def each
yield 0
yield(-1)
yield 2
yield 2/3r
end
describe 'Enumerable#sum' do
before :each do
@enum = Object.new.to_enum
class << @enum
def each
yield 0
yield(-1)
yield 2
yield 2/3r
end
end
end
it 'returns amount of the elements with taking an argument as the initial value' do
@enum.sum(10).should == 35/3r
end
it 'returns amount of the elements with taking an argument as the initial value' do
@enum.sum(10).should == 35/3r
end
it 'gives 0 as a default argument' do
@enum.sum.should == 5/3r
end
it 'gives 0 as a default argument' do
@enum.sum.should == 5/3r
end
it 'takes a block to transform the elements' do
@enum.sum { |element| element * 2 }.should == 10/3r
end
it 'takes a block to transform the elements' do
@enum.sum { |element| element * 2 }.should == 10/3r
end
end

140
spec/ruby/core/enumerable/uniq_spec.rb
Просмотреть файл

@ -1,94 +1,90 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is '2.4' do
describe 'Enumerable#uniq' do
it 'returns an array that contains only unique elements' do
[0, 1, 2, 3].to_enum.uniq { |n| n.even? }.should == [0, 1]
end
describe 'Enumerable#uniq' do
it 'returns an array that contains only unique elements' do
[0, 1, 2, 3].to_enum.uniq { |n| n.even? }.should == [0, 1]
end
it "uses eql? semantics" do
[1.0, 1].to_enum.uniq.should == [1.0, 1]
end
it "uses eql? semantics" do
[1.0, 1].to_enum.uniq.should == [1.0, 1]
end
it "compares elements first with hash" do
x = mock('0')
x.should_receive(:hash).at_least(1).and_return(0)
y = mock('0')
y.should_receive(:hash).at_least(1).and_return(0)
it "compares elements first with hash" do
x = mock('0')
x.should_receive(:hash).at_least(1).and_return(0)
y = mock('0')
y.should_receive(:hash).at_least(1).and_return(0)
[x, y].to_enum.uniq.should == [x, y]
end
[x, y].to_enum.uniq.should == [x, y]
end
it "does not compare elements with different hash codes via eql?" do
x = mock('0')
x.should_not_receive(:eql?)
y = mock('1')
y.should_not_receive(:eql?)
it "does not compare elements with different hash codes via eql?" do
x = mock('0')
x.should_not_receive(:eql?)
y = mock('1')
y.should_not_receive(:eql?)
x.should_receive(:hash).at_least(1).and_return(0)
y.should_receive(:hash).at_least(1).and_return(1)
x.should_receive(:hash).at_least(1).and_return(0)
y.should_receive(:hash).at_least(1).and_return(1)
[x, y].to_enum.uniq.should == [x, y]
end
[x, y].to_enum.uniq.should == [x, y]
end
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)
# It's undefined whether the impl does a[0].eql?(a[1]) or
# a[1].eql?(a[0]) so we taint both.
taint
o.taint
false
end
obj
def obj.eql?(o)
# It's undefined whether the impl does a[0].eql?(a[1]) or
# a[1].eql?(a[0]) so we taint both.
taint
o.taint
false
end
a.uniq.should == a
a[0].tainted?.should == true
a[1].tainted?.should == true
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].tainted?.should == true
a[1].tainted?.should == true
obj
end
context 'when yielded with multiple arguments' do
before :each do
@enum = Object.new.to_enum
class << @enum
def each
yield 0, 'foo'
yield 1, 'FOO'
yield 2, 'bar'
end
end
a.uniq.should == a
a[0].tainted?.should == true
a[1].tainted?.should == 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].eql?(a[1]) or
# a[1].eql?(a[0]) so we taint both.
taint
o.taint
true
end
ruby_bug '#13669', ''...'2.5' do
it 'returns all yield arguments as an array' do
@enum.uniq { |_, label| label.downcase }.should == [[0, 'foo'], [2, 'bar']]
obj
end
a.to_enum.uniq.size.should == 1
a[0].tainted?.should == true
a[1].tainted?.should == true
end
context 'when yielded with multiple arguments' do
before :each do
@enum = Object.new.to_enum
class << @enum
def each
yield 0, 'foo'
yield 1, 'FOO'
yield 2, 'bar'
end
end
end
it 'returns all yield arguments as an array' do
@enum.uniq { |_, label| label.downcase }.should == [[0, 'foo'], [2, 'bar']]
end
end
end

20
spec/ruby/core/enumerator/lazy/chunk_spec.rb
Просмотреть файл

@ -25,22 +25,12 @@ describe "Enumerator::Lazy#chunk" do
Enumerator::Lazy.new(Object.new, 100) {}.chunk { |v| v }.size.should == nil
end
ruby_version_is ""..."2.4" do
it "raises an ArgumentError if called without a block" do
lambda do
@yieldsmixed.chunk
end.should raise_error(ArgumentError)
end
end
it "returns an Enumerator if called without a block" do
chunk = @yieldsmixed.chunk
chunk.should be_an_instance_of(Enumerator::Lazy)
ruby_version_is "2.4" do
it "returns an Enumerator if called without a block" do
chunk = @yieldsmixed.chunk
chunk.should be_an_instance_of(Enumerator::Lazy)
res = chunk.each { |v| true }.force
res.should == [[true, EnumeratorLazySpecs::YieldsMixed.gathered_yields]]
end
res = chunk.each { |v| true }.force
res.should == [[true, EnumeratorLazySpecs::YieldsMixed.gathered_yields]]
end
describe "when the returned lazy enumerator is evaluated by Enumerable#first" do

4
spec/ruby/core/enumerator/lazy/lazy_spec.rb
Просмотреть файл

@ -14,9 +14,7 @@ describe "Enumerator::Lazy" do
:select, :slice_after, :slice_before, :slice_when, :take, :take_while,
:to_enum, :zip
]
ruby_version_is "2.4" do
lazy_methods += [:chunk_while, :uniq]
end
lazy_methods += [:chunk_while, :uniq]
Enumerator::Lazy.instance_methods(false).should include(*lazy_methods)
end

39
spec/ruby/core/enumerator/lazy/select_spec.rb
Просмотреть файл

@ -5,4 +5,43 @@ require_relative 'shared/select'
describe "Enumerator::Lazy#select" do
it_behaves_like :enumerator_lazy_select, :select
it "doesn't pre-evaluate the next element" do
eval_count = 0
enum = %w[Text1 Text2 Text3].lazy.select do
eval_count += 1
true
end
eval_count.should == 0
enum.next
eval_count.should == 1
end
it "doesn't over-evaluate when peeked" do
eval_count = 0
enum = %w[Text1 Text2 Text3].lazy.select do
eval_count += 1
true
end
eval_count.should == 0
enum.peek
enum.peek
eval_count.should == 1
end
it "doesn't re-evaluate after peek" do
eval_count = 0
enum = %w[Text1 Text2 Text3].lazy.select do
eval_count += 1
true
end
eval_count.should == 0
enum.peek
eval_count.should == 1
enum.next
eval_count.should == 1
end
end

132
spec/ruby/core/enumerator/lazy/uniq_spec.rb
Просмотреть файл

@ -1,82 +1,74 @@
require_relative '../../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is '2.4' do
describe 'Enumerator::Lazy#uniq' do
context 'without block' do
before :each do
@lazy = [0, 1, 0, 1].to_enum.lazy.uniq
end
it 'returns a lazy enumerator' do
@lazy.should be_an_instance_of(Enumerator::Lazy)
@lazy.force.should == [0, 1]
end
ruby_bug "#14495", "2.4"..."2.5.2" do
it 'return same value after rewind' do
@lazy.force.should == [0, 1]
@lazy.force.should == [0, 1]
end
end
it 'sets the size to nil' do
@lazy.size.should == nil
end
describe 'Enumerator::Lazy#uniq' do
context 'without block' do
before :each do
@lazy = [0, 1, 0, 1].to_enum.lazy.uniq
end
context 'when yielded with an argument' do
before :each do
@lazy = [0, 1, 2, 3].to_enum.lazy.uniq(&:even?)
end
it 'returns a lazy enumerator' do
@lazy.should be_an_instance_of(Enumerator::Lazy)
@lazy.force.should == [0, 1]
end
ruby_bug "#14495", "2.4"..."2.5.2" do
it 'return same value after rewind' do
@lazy.force.should == [0, 1]
@lazy.force.should == [0, 1]
end
end
it 'sets the size to nil' do
@lazy.size.should == nil
end
it 'returns a lazy enumerator' do
@lazy.should be_an_instance_of(Enumerator::Lazy)
@lazy.force.should == [0, 1]
end
context 'when yielded with multiple arguments' do
before :each do
enum = Object.new.to_enum
class << enum
def each
yield 0, 'foo'
yield 1, 'FOO'
yield 2, 'bar'
end
end
@lazy = enum.lazy
end
ruby_bug "#14495", "2.4"..."2.5.2" do
it 'return same value after rewind' do
enum = @lazy.uniq { |_, label| label.downcase }
enum.force.should == [[0, 'foo'], [2, 'bar']]
enum.force.should == [[0, 'foo'], [2, 'bar']]
end
end
it 'returns all yield arguments as an array' do
@lazy.uniq { |_, label| label.downcase }.force.should == [[0, 'foo'], [2, 'bar']]
end
it 'return same value after rewind' do
@lazy.force.should == [0, 1]
@lazy.force.should == [0, 1]
end
it "works with an infinite enumerable" do
s = 0..Float::INFINITY
s.lazy.uniq.first(100).should ==
s.first(100).uniq
it 'sets the size to nil' do
@lazy.size.should == nil
end
end
context 'when yielded with an argument' do
before :each do
@lazy = [0, 1, 2, 3].to_enum.lazy.uniq(&:even?)
end
it 'returns a lazy enumerator' do
@lazy.should be_an_instance_of(Enumerator::Lazy)
@lazy.force.should == [0, 1]
end
it 'return same value after rewind' do
@lazy.force.should == [0, 1]
@lazy.force.should == [0, 1]
end
it 'sets the size to nil' do
@lazy.size.should == nil
end
end
context 'when yielded with multiple arguments' do
before :each do
enum = Object.new.to_enum
class << enum
def each
yield 0, 'foo'
yield 1, 'FOO'
yield 2, 'bar'
end
end
@lazy = enum.lazy
end
it 'return same value after rewind' do
enum = @lazy.uniq { |_, label| label.downcase }
enum.force.should == [[0, 'foo'], [2, 'bar']]
enum.force.should == [[0, 'foo'], [2, 'bar']]
end
it 'returns all yield arguments as an array' do
@lazy.uniq { |_, label| label.downcase }.force.should == [[0, 'foo'], [2, 'bar']]
end
end
it "works with an infinite enumerable" do
s = 0..Float::INFINITY
s.lazy.uniq.first(100).should ==
s.first(100).uniq
end
end

6
spec/ruby/core/env/fetch_spec.rb поставляемый
Просмотреть файл

@ -14,6 +14,12 @@ describe "ENV.fetch" do
context "when the key is not found" do
it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, ENV
it "formats the object with #inspect in the KeyError message" do
-> {
ENV.fetch('foo')
}.should raise_error(KeyError, 'key not found: "foo"')
end
end
it "provides the given default parameter" do

8
spec/ruby/core/false/dup_spec.rb
Просмотреть файл

@ -1,9 +1,7 @@
require_relative '../../spec_helper'
ruby_version_is '2.4' do
describe "FalseClass#dup" do
it "returns self" do
false.dup.should equal(false)
end
describe "FalseClass#dup" do
it "returns self" do
false.dup.should equal(false)
end
end

2
spec/ruby/core/fiber/resume_spec.rb
Просмотреть файл

@ -42,7 +42,7 @@ with_feature :fiber do
f.resume
# When we execute the second #resume call, the ensure block DOES exit,
# the ensure clause runs. This is Ruby behavior as of 2.3.1.
# the ensure clause runs.
f.resume
exit 0

12
spec/ruby/core/file/empty_spec.rb
Просмотреть файл

@ -2,14 +2,12 @@ require_relative '../../spec_helper'
require_relative '../../shared/file/zero'
describe "File.empty?" do
ruby_version_is "2.4" do
it_behaves_like :file_zero, :empty?, File
it_behaves_like :file_zero_missing, :empty?, File
it_behaves_like :file_zero, :empty?, File
it_behaves_like :file_zero_missing, :empty?, File
platform_is :solaris do
it "returns false for /dev/null" do
File.empty?('/dev/null').should == true
end
platform_is :solaris do
it "returns false for /dev/null" do
File.empty?('/dev/null').should == true
end
end
end

16
spec/ruby/core/file/expand_path_spec.rb
Просмотреть файл

@ -222,16 +222,14 @@ platform_is_not :windows do
ENV["HOME"] = @home
end
ruby_version_is ''...'2.4' do
it "raises an ArgumentError when passed '~' if HOME is nil" do
ENV.delete "HOME"
lambda { File.expand_path("~") }.should raise_error(ArgumentError)
end
it "uses the user database when passed '~' if HOME is nil" do
ENV.delete "HOME"
File.directory?(File.expand_path("~")).should == true
end
it "raises an ArgumentError when passed '~/' if HOME is nil" do
ENV.delete "HOME"
lambda { File.expand_path("~/") }.should raise_error(ArgumentError)
end
it "uses the user database when passed '~/' if HOME is nil" do
ENV.delete "HOME"
File.directory?(File.expand_path("~/")).should == true
end
it "raises an ArgumentError when passed '~' if HOME == ''" do

2
spec/ruby/core/file/mtime_spec.rb
Просмотреть файл

@ -12,7 +12,7 @@ describe "File.mtime" do
it "returns the modification Time of the file" do
File.mtime(@filename).should be_kind_of(Time)
File.mtime(@filename).should be_close(@mtime, 60.0)
File.mtime(@filename).should be_close(@mtime, TIME_TOLERANCE)
end
guard -> { platform_is :linux or (platform_is :windows and ruby_version_is '2.5') } do

8
spec/ruby/core/file/stat/dev_major_spec.rb
Просмотреть файл

@ -9,11 +9,9 @@ describe "File::Stat#dev_major" do
rm_r @name
end
ruby_version_is "2.4" do
platform_is_not :windows do
it "returns the major part of File::Stat#dev" do
File.stat(@name).dev_major.should be_kind_of(Integer)
end
platform_is_not :windows do
it "returns the major part of File::Stat#dev" do
File.stat(@name).dev_major.should be_kind_of(Integer)
end
end

8
spec/ruby/core/file/stat/dev_minor_spec.rb
Просмотреть файл

@ -9,11 +9,9 @@ describe "File::Stat#dev_minor" do
rm_r @name
end
ruby_version_is "2.4" do
platform_is_not :windows do
it "returns the minor part of File::Stat#dev" do
File.stat(@name).dev_minor.should be_kind_of(Integer)
end
platform_is_not :windows do
it "returns the minor part of File::Stat#dev" do
File.stat(@name).dev_minor.should be_kind_of(Integer)
end
end

8
spec/ruby/core/file/stat/rdev_major_spec.rb
Просмотреть файл

@ -17,11 +17,9 @@ describe "File::Stat#rdev_major" do
end
end
ruby_version_is "2.4" do
platform_is_not :windows do
it "returns the major part of File::Stat#rdev" do
File.stat(@name).rdev_major.should be_kind_of(Integer)
end
platform_is_not :windows do
it "returns the major part of File::Stat#rdev" do
File.stat(@name).rdev_major.should be_kind_of(Integer)
end
end

8
spec/ruby/core/file/stat/rdev_minor_spec.rb
Просмотреть файл

@ -17,11 +17,9 @@ describe "File::Stat#rdev_minor" do
end
end
ruby_version_is "2.4" do
platform_is_not :windows do
it "returns the minor part of File::Stat#rdev" do
File.stat(@name).rdev_minor.should be_kind_of(Integer)
end
platform_is_not :windows do
it "returns the minor part of File::Stat#rdev" do
File.stat(@name).rdev_minor.should be_kind_of(Integer)
end
end

24
spec/ruby/core/file/utime_spec.rb
Просмотреть файл

@ -27,10 +27,10 @@ describe "File.utime" do
File.atime(@file2).should be_close(@atime, 0.0001)
File.mtime(@file2).should be_close(@mtime, 0.0001)
else
File.atime(@file1).to_i.should be_close(@atime.to_i, 2)
File.mtime(@file1).to_i.should be_close(@mtime.to_i, 2)
File.atime(@file2).to_i.should be_close(@atime.to_i, 2)
File.mtime(@file2).to_i.should be_close(@mtime.to_i, 2)
File.atime(@file1).to_i.should be_close(@atime.to_i, TIME_TOLERANCE)
File.mtime(@file1).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE)
File.atime(@file2).to_i.should be_close(@atime.to_i, TIME_TOLERANCE)
File.mtime(@file2).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE)
end
end
@ -43,10 +43,10 @@ describe "File.utime" do
File.atime(@file2).should be_close(tn, 0.050)
File.mtime(@file2).should be_close(tn, 0.050)
else
File.atime(@file1).to_i.should be_close(Time.now.to_i, 2)
File.mtime(@file1).to_i.should be_close(Time.now.to_i, 2)
File.atime(@file2).to_i.should be_close(Time.now.to_i, 2)
File.mtime(@file2).to_i.should be_close(Time.now.to_i, 2)
File.atime(@file1).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE)
File.mtime(@file1).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE)
File.atime(@file2).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE)
File.mtime(@file2).to_i.should be_close(Time.now.to_i, TIME_TOLERANCE)
end
end
@ -63,10 +63,10 @@ describe "File.utime" do
File.mtime(@file2).should be_close(@mtime, 0.0001)
else
File.utime(@atime.to_i, @mtime.to_i, @file1, @file2)
File.atime(@file1).to_i.should be_close(@atime.to_i, 2)
File.mtime(@file1).to_i.should be_close(@mtime.to_i, 2)
File.atime(@file2).to_i.should be_close(@atime.to_i, 2)
File.mtime(@file2).to_i.should be_close(@mtime.to_i, 2)
File.atime(@file1).to_i.should be_close(@atime.to_i, TIME_TOLERANCE)
File.mtime(@file1).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE)
File.atime(@file2).to_i.should be_close(@atime.to_i, TIME_TOLERANCE)
File.mtime(@file2).to_i.should be_close(@mtime.to_i, TIME_TOLERANCE)
end
end

14
spec/ruby/core/float/ceil_spec.rb
Просмотреть файл

@ -11,13 +11,11 @@ describe "Float#ceil" do
+9223372036854775808.1.ceil.should eql(+9223372036854775808)
end
ruby_version_is "2.4" do
it "returns the smallest number greater than or equal to self with an optionally given precision" do
2.1679.ceil(0).should eql(3)
214.94.ceil(-1).should eql(220)
7.0.ceil(1).should eql(7.0)
-1.234.ceil(2).should eql(-1.23)
5.123812.ceil(4).should eql(5.1239)
end
it "returns the smallest number greater than or equal to self with an optionally given precision" do
2.1679.ceil(0).should eql(3)
214.94.ceil(-1).should eql(220)
7.0.ceil(1).should eql(7.0)
-1.234.ceil(2).should eql(-1.23)
5.123812.ceil(4).should eql(5.1239)
end
end

10
spec/ruby/core/float/dup_spec.rb
Просмотреть файл

@ -1,10 +1,8 @@
require_relative '../../spec_helper'
ruby_version_is '2.4' do
describe "Float#dup" do
it "returns self" do
float = 2.4
float.dup.should equal(float)
end
describe "Float#dup" do
it "returns self" do
float = 2.4
float.dup.should equal(float)
end
end

14
spec/ruby/core/float/floor_spec.rb
Просмотреть файл

@ -11,13 +11,11 @@ describe "Float#floor" do
+9223372036854775808.1.floor.should eql(+9223372036854775808)
end
ruby_version_is "2.4" do
it "returns the largest number less than or equal to self with an optionally given precision" do
2.1679.floor(0).should eql(2)
214.94.floor(-1).should eql(210)
7.0.floor(1).should eql(7.0)
-1.234.floor(2).should eql(-1.24)
5.123812.floor(4).should eql(5.1238)
end
it "returns the largest number less than or equal to self with an optionally given precision" do
2.1679.floor(0).should eql(2)
214.94.floor(-1).should eql(210)
7.0.floor(1).should eql(7.0)
-1.234.floor(2).should eql(-1.24)
5.123812.floor(4).should eql(5.1238)
end
end

42
spec/ruby/core/float/round_spec.rb
Просмотреть файл

@ -83,17 +83,35 @@ describe "Float#round" do
-2.4e200.round(-200).should eql( -2 * 10 ** 200 )
end
ruby_version_is "2.4" do
it "returns different rounded values depending on the half option" do
2.5.round(half: :up).should eql(3)
2.5.round(half: :down).should eql(2)
2.5.round(half: :even).should eql(2)
3.5.round(half: :up).should eql(4)
3.5.round(half: :down).should eql(3)
3.5.round(half: :even).should eql(4)
(-2.5).round(half: :up).should eql(-3)
(-2.5).round(half: :down).should eql(-2)
(-2.5).round(half: :even).should eql(-2)
end
it "returns different rounded values depending on the half option" do
2.5.round(half: nil).should eql(3)
2.5.round(half: :up).should eql(3)
2.5.round(half: :down).should eql(2)
2.5.round(half: :even).should eql(2)
3.5.round(half: nil).should eql(4)
3.5.round(half: :up).should eql(4)
3.5.round(half: :down).should eql(3)
3.5.round(half: :even).should eql(4)
(-2.5).round(half: nil).should eql(-3)
(-2.5).round(half: :up).should eql(-3)
(-2.5).round(half: :down).should eql(-2)
(-2.5).round(half: :even).should eql(-2)
end
it "rounds self to an optionally given precision with a half option" do
5.55.round(1, half: nil).should eql(5.6)
5.55.round(1, half: :up).should eql(5.6)
5.55.round(1, half: :down).should eql(5.5)
5.55.round(1, half: :even).should eql(5.6)
end
it "raises FloatDomainError for exceptional values with a half option" do
lambda { (+infinity_value).round(half: :up) }.should raise_error(FloatDomainError)
lambda { (-infinity_value).round(half: :down) }.should raise_error(FloatDomainError)
lambda { nan_value.round(half: :even) }.should raise_error(FloatDomainError)
end
it "raise for a non-existent round mode" do
lambda { 14.2.round(half: :nonsense) }.should raise_error(ArgumentError, "invalid rounding mode: nonsense")
end
end

14
spec/ruby/core/float/truncate_spec.rb
Просмотреть файл

@ -4,13 +4,11 @@ require_relative 'shared/to_i'
describe "Float#truncate" do
it_behaves_like :float_to_i, :truncate
ruby_version_is "2.4" do
it "returns self truncated to an optionally given precision" do
2.1679.truncate(0).should eql(2)
7.1.truncate(1).should eql(7.1)
214.94.truncate(-1).should eql(210)
-1.234.truncate(2).should eql(-1.23)
5.123812.truncate(4).should eql(5.1238)
end
it "returns self truncated to an optionally given precision" do
2.1679.truncate(0).should eql(2)
7.1.truncate(1).should eql(7.1)
214.94.truncate(-1).should eql(210)
-1.234.truncate(2).should eql(-1.23)
5.123812.truncate(4).should eql(5.1238)
end
end

96
spec/ruby/core/hash/compact_spec.rb
Просмотреть файл

@ -1,61 +1,59 @@
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
ruby_version_is "2.4" do
describe "Hash#compact" do
describe "Hash#compact" do
before :each do
@hash = { truthy: true, false: false, nil: nil, nil => true }
@initial_pairs = @hash.dup
@compact = { truthy: true, false: false, nil => true }
end
it "returns new object that rejects pair has nil value" do
ret = @hash.compact
ret.should_not equal(@hash)
ret.should == @compact
end
it "keeps own pairs" do
@hash.compact
@hash.should == @initial_pairs
end
end
describe "Hash#compact!" do
before :each do
@hash = { truthy: true, false: false, nil: nil, nil => true }
@initial_pairs = @hash.dup
@compact = { truthy: true, false: false, nil => true }
end
it "returns self" do
@hash.compact!.should equal(@hash)
end
it "rejects own pair has nil value" do
@hash.compact!
@hash.should == @compact
end
context "when each pair does not have nil value" do
before :each do
@hash = { truthy: true, false: false, nil: nil, nil => true }
@initial_pairs = @hash.dup
@compact = { truthy: true, false: false, nil => true }
@hash.compact!
end
it "returns new object that rejects pair has nil value" do
ret = @hash.compact
ret.should_not equal(@hash)
ret.should == @compact
it "returns nil" do
@hash.compact!.should be_nil
end
end
describe "on frozen instance" do
before :each do
@hash.freeze
end
it "keeps own pairs" do
@hash.compact
it "keeps pairs and raises a #{frozen_error_class}" do
->{ @hash.compact! }.should raise_error(frozen_error_class)
@hash.should == @initial_pairs
end
end
describe "Hash#compact!" do
before :each do
@hash = { truthy: true, false: false, nil: nil, nil => true }
@initial_pairs = @hash.dup
@compact = { truthy: true, false: false, nil => true }
end
it "returns self" do
@hash.compact!.should equal(@hash)
end
it "rejects own pair has nil value" do
@hash.compact!
@hash.should == @compact
end
context "when each pair does not have nil value" do
before :each do
@hash.compact!
end
it "returns nil" do
@hash.compact!.should be_nil
end
end
describe "on frozen instance" do
before :each do
@hash.freeze
end
it "keeps pairs and raises a #{frozen_error_class}" do
->{ @hash.compact! }.should raise_error(frozen_error_class)
@hash.should == @initial_pairs
end
end
end
end

12
spec/ruby/core/hash/compare_by_identity_spec.rb
Просмотреть файл

@ -108,13 +108,11 @@ describe "Hash#compare_by_identity" do
@idh.keys.first.should equal foo
end
ruby_bug "#12855", ""..."2.4.1" do
it "gives different identity for string literals" do
@idh['foo'] = 1
@idh['foo'] = 2
@idh.values.should == [1, 2]
@idh.size.should == 2
end
it "gives different identity for string literals" do
@idh['foo'] = 1
@idh['foo'] = 2
@idh.values.should == [1, 2]
@idh.size.should == 2
end
end

6
spec/ruby/core/hash/fetch_spec.rb
Просмотреть файл

@ -8,6 +8,12 @@ describe "Hash#fetch" do
it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, {}
it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, Hash.new { 5 }
it_behaves_like :key_error, ->(obj, key) { obj.fetch(key) }, Hash.new(5)
it "formats the object with #inspect in the KeyError message" do
-> {
{}.fetch('foo')
}.should raise_error(KeyError, 'key not found: "foo"')
end
end
it "returns the value for key" do

7
spec/ruby/core/hash/merge_spec.rb
Просмотреть файл

@ -69,9 +69,12 @@ describe "Hash#merge" do
result.should == { a: 1, b: 2, c: 3, d: 4 }
end
it "accepts zero arguments and returns self" do
it "accepts zero arguments and returns a copy of self" do
hash = { a: 1 }
hash.merge.should eql(hash)
merged = hash.merge
merged.should eql(hash)
merged.should_not equal(hash)
end
end
end

2
spec/ruby/core/hash/shared/each.rb
Просмотреть файл

@ -21,7 +21,7 @@ describe :hash_each, shared: true do
ary.sort.should == ["a", "b", "c"]
end
it "yields 2 values and not an Array of 2 elements" do
it "yields 2 values and not an Array of 2 elements when given a callable of arity 2" do
obj = Object.new
def obj.foo(key, value)
ScratchPad << key << value

154
spec/ruby/core/hash/transform_values_spec.rb
Просмотреть файл

@ -1,98 +1,96 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Hash#transform_values" do
before :each do
@hash = { a: 1, b: 2, c: 3 }
end
describe "Hash#transform_values" do
before :each do
@hash = { a: 1, b: 2, c: 3 }
end
it "returns new hash" do
ret = @hash.transform_values(&:succ)
ret.should_not equal(@hash)
ret.should be_an_instance_of(Hash)
end
it "returns new hash" do
ret = @hash.transform_values(&:succ)
ret.should_not equal(@hash)
ret.should be_an_instance_of(Hash)
end
it "sets the result as transformed values with the given block" do
@hash.transform_values(&:succ).should == { a: 2, b: 3, c: 4 }
end
it "sets the result as transformed values with the given block" do
@hash.transform_values(&:succ).should == { a: 2, b: 3, c: 4 }
end
it "makes both hashes to share keys" do
key = [1, 2, 3]
new_hash = { key => 1 }.transform_values(&:succ)
new_hash[key].should == 2
new_hash.keys[0].should equal(key)
end
it "makes both hashes to share keys" do
key = [1, 2, 3]
new_hash = { key => 1 }.transform_values(&:succ)
new_hash[key].should == 2
new_hash.keys[0].should equal(key)
end
context "when no block is given" do
it "returns a sized Enumerator" do
enumerator = @hash.transform_values
enumerator.should be_an_instance_of(Enumerator)
enumerator.size.should == @hash.size
enumerator.each(&:succ).should == { a: 2, b: 3, c: 4 }
end
end
it "returns a Hash instance, even on subclasses" do
klass = Class.new(Hash)
h = klass.new
h[:foo] = 42
r = h.transform_values{|v| 2 * v}
r[:foo].should == 84
r.class.should == Hash
context "when no block is given" do
it "returns a sized Enumerator" do
enumerator = @hash.transform_values
enumerator.should be_an_instance_of(Enumerator)
enumerator.size.should == @hash.size
enumerator.each(&:succ).should == { a: 2, b: 3, c: 4 }
end
end
describe "Hash#transform_values!" do
before :each do
@hash = { a: 1, b: 2, c: 3 }
@initial_pairs = @hash.dup
end
it "returns a Hash instance, even on subclasses" do
klass = Class.new(Hash)
h = klass.new
h[:foo] = 42
r = h.transform_values{|v| 2 * v}
r[:foo].should == 84
r.class.should == Hash
end
end
it "returns self" do
@hash.transform_values!(&:succ).should equal(@hash)
end
describe "Hash#transform_values!" do
before :each do
@hash = { a: 1, b: 2, c: 3 }
@initial_pairs = @hash.dup
end
it "updates self as transformed values with the given block" do
@hash.transform_values!(&:succ)
it "returns self" do
@hash.transform_values!(&:succ).should equal(@hash)
end
it "updates self as transformed values with the given block" do
@hash.transform_values!(&:succ)
@hash.should == { a: 2, b: 3, c: 4 }
end
it "partially modifies the contents if we broke from the block" do
@hash.transform_values! do |v|
break if v == 3
100 + v
end
@hash.should == { a: 101, b: 102, c: 3}
end
context "when no block is given" do
it "returns a sized Enumerator" do
enumerator = @hash.transform_values!
enumerator.should be_an_instance_of(Enumerator)
enumerator.size.should == @hash.size
enumerator.each(&:succ)
@hash.should == { a: 2, b: 3, c: 4 }
end
end
it "partially modifies the contents if we broke from the block" do
@hash.transform_values! do |v|
break if v == 3
100 + v
end
@hash.should == { a: 101, b: 102, c: 3}
describe "on frozen instance" do
before :each do
@hash.freeze
end
it "raises a #{frozen_error_class} on an empty hash" do
->{ {}.freeze.transform_values!(&:succ) }.should raise_error(frozen_error_class)
end
it "keeps pairs and raises a #{frozen_error_class}" do
->{ @hash.transform_values!(&:succ) }.should raise_error(frozen_error_class)
@hash.should == @initial_pairs
end
context "when no block is given" do
it "returns a sized Enumerator" do
enumerator = @hash.transform_values!
enumerator.should be_an_instance_of(Enumerator)
enumerator.size.should == @hash.size
enumerator.each(&:succ)
@hash.should == { a: 2, b: 3, c: 4 }
end
end
describe "on frozen instance" do
before :each do
@hash.freeze
end
it "raises a #{frozen_error_class} on an empty hash" do
->{ {}.freeze.transform_values!(&:succ) }.should raise_error(frozen_error_class)
end
it "keeps pairs and raises a #{frozen_error_class}" do
->{ @hash.transform_values!(&:succ) }.should raise_error(frozen_error_class)
@hash.should == @initial_pairs
end
context "when no block is given" do
it "does not raise an exception" do
@hash.transform_values!.should be_an_instance_of(Enumerator)
end
it "does not raise an exception" do
@hash.transform_values!.should be_an_instance_of(Enumerator)
end
end
end

18
spec/ruby/core/integer/ceil_spec.rb
Просмотреть файл

@ -6,16 +6,14 @@ describe "Integer#ceil" do
it_behaves_like :integer_to_i, :ceil
it_behaves_like :integer_rounding_positive_precision, :ceil
ruby_version_is "2.4" do
context "precision argument specified as part of the ceil method is negative" do
it "returns the smallest integer greater than self with at least precision.abs trailing zeros" do
18.ceil(-1).should eql(20)
18.ceil(-2).should eql(100)
18.ceil(-3).should eql(1000)
-1832.ceil(-1).should eql(-1830)
-1832.ceil(-2).should eql(-1800)
-1832.ceil(-3).should eql(-1000)
end
context "precision argument specified as part of the ceil method is negative" do
it "returns the smallest integer greater than self with at least precision.abs trailing zeros" do
18.ceil(-1).should eql(20)
18.ceil(-2).should eql(100)
18.ceil(-3).should eql(1000)
-1832.ceil(-1).should eql(-1830)
-1832.ceil(-2).should eql(-1800)
-1832.ceil(-3).should eql(-1000)
end
end
end

40
spec/ruby/core/integer/coerce_spec.rb
Просмотреть файл

@ -68,38 +68,24 @@ describe "Integer#coerce" do
lambda { a.coerce(:test) }.should raise_error(TypeError)
end
ruby_version_is ""..."2.4" do
it "raises a TypeError when passed a String" do
a = bignum_value
lambda { a.coerce("123") }.should raise_error(TypeError)
end
it "raises a TypeError when passed a Float" do
a = bignum_value
lambda { a.coerce(12.3) }.should raise_error(TypeError)
end
it "coerces both values to Floats and returns [other, self] when passed a Float" do
a = bignum_value
a.coerce(1.2).should == [1.2, a.to_f]
end
ruby_version_is "2.4" do
it "coerces both values to Floats and returns [other, self] when passed a Float" do
a = bignum_value
a.coerce(1.2).should == [1.2, a.to_f]
end
it "coerces both values to Floats and returns [other, self] when passed a String" do
a = bignum_value
a.coerce("123").should == [123.0, a.to_f]
end
it "coerces both values to Floats and returns [other, self] when passed a String" do
a = bignum_value
a.coerce("123").should == [123.0, a.to_f]
end
it "calls #to_f to coerce other to a Float" do
b = mock("bignum value")
b.should_receive(:to_f).and_return(1.2)
it "calls #to_f to coerce other to a Float" do
b = mock("bignum value")
b.should_receive(:to_f).and_return(1.2)
a = bignum_value
ary = a.coerce(b)
a = bignum_value
ary = a.coerce(b)
ary.should == [1.2, a.to_f]
end
ary.should == [1.2, a.to_f]
end
end
end

46
spec/ruby/core/integer/digits_spec.rb
Просмотреть файл

@ -1,34 +1,32 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Integer#digits" do
it "returns an array of place values in base-10 by default" do
12345.digits.should == [5,4,3,2,1]
end
describe "Integer#digits" do
it "returns an array of place values in base-10 by default" do
12345.digits.should == [5,4,3,2,1]
end
it "returns digits by place value of a given radix" do
12345.digits(7).should == [4,6,6,0,5]
end
it "returns digits by place value of a given radix" do
12345.digits(7).should == [4,6,6,0,5]
end
it "converts the radix with #to_int" do
12345.digits(mock_int(2)).should == [1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1]
end
it "converts the radix with #to_int" do
12345.digits(mock_int(2)).should == [1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1]
end
it "returns [0] when called on 0, regardless of base" do
0.digits.should == [0]
0.digits(7).should == [0]
end
it "returns [0] when called on 0, regardless of base" do
0.digits.should == [0]
0.digits(7).should == [0]
end
it "raises ArgumentError when calling with a radix less than 2" do
lambda { 12345.digits(1) }.should raise_error(ArgumentError)
end
it "raises ArgumentError when calling with a radix less than 2" do
lambda { 12345.digits(1) }.should raise_error(ArgumentError)
end
it "raises ArgumentError when calling with a negative radix" do
lambda { 12345.digits(-2) }.should raise_error(ArgumentError)
end
it "raises ArgumentError when calling with a negative radix" do
lambda { 12345.digits(-2) }.should raise_error(ArgumentError)
end
it "raises Math::DomainError when calling digits on a negative number" do
lambda { -12345.digits(7) }.should raise_error(Math::DomainError)
end
it "raises Math::DomainError when calling digits on a negative number" do
lambda { -12345.digits(7) }.should raise_error(Math::DomainError)
end
end

18
spec/ruby/core/integer/dup_spec.rb
Просмотреть файл

@ -1,15 +1,13 @@
require_relative '../../spec_helper'
ruby_version_is '2.4' do
describe "Integer#dup" do
it "returns self for small integers" do
integer = 1_000
integer.dup.should equal(integer)
end
describe "Integer#dup" do
it "returns self for small integers" do
integer = 1_000
integer.dup.should equal(integer)
end
it "returns self for large integers" do
integer = 4_611_686_018_427_387_905
integer.dup.should equal(integer)
end
it "returns self for large integers" do
integer = 4_611_686_018_427_387_905
integer.dup.should equal(integer)
end
end

18
spec/ruby/core/integer/floor_spec.rb
Просмотреть файл

@ -6,16 +6,14 @@ describe "Integer#floor" do
it_behaves_like :integer_to_i, :floor
it_behaves_like :integer_rounding_positive_precision, :floor
ruby_version_is "2.4" do
context "precision argument specified as part of the floor method is negative" do
it "returns the largest integer less than self with at least precision.abs trailing zeros" do
1832.floor(-1).should eql(1830)
1832.floor(-2).should eql(1800)
1832.floor(-3).should eql(1000)
-1832.floor(-1).should eql(-1840)
-1832.floor(-2).should eql(-1900)
-1832.floor(-3).should eql(-2000)
end
context "precision argument specified as part of the floor method is negative" do
it "returns the largest integer less than self with at least precision.abs trailing zeros" do
1832.floor(-1).should eql(1830)
1832.floor(-2).should eql(1800)
1832.floor(-3).should eql(1000)
-1832.floor(-1).should eql(-1840)
-1832.floor(-2).should eql(-1900)
-1832.floor(-3).should eql(-2000)
end
end
end

8
spec/ruby/core/integer/integer_spec.rb
Просмотреть файл

@ -5,11 +5,9 @@ describe "Integer" do
Integer.include?(Comparable).should == true
end
ruby_version_is "2.4" do
it "is the class of both small and large integers" do
42.class.should equal(Integer)
bignum_value.class.should equal(Integer)
end
it "is the class of both small and large integers" do
42.class.should equal(Integer)
bignum_value.class.should equal(Integer)
end
end

12
spec/ruby/core/integer/pow_spec.rb
Просмотреть файл

@ -16,13 +16,11 @@ ruby_version_is "2.5" do
2.pow(8, 15).should == 1
end
ruby_bug '#13669', '2.5'...'2.5.1' do
it "works well with bignums" do
2.pow(61, 5843009213693951).should eql 3697379018277258
2.pow(62, 5843009213693952).should eql 1551748822859776
2.pow(63, 5843009213693953).should eql 3103497645717974
2.pow(64, 5843009213693954).should eql 363986077738838
end
it "works well with bignums" do
2.pow(61, 5843009213693951).should eql 3697379018277258
2.pow(62, 5843009213693952).should eql 1551748822859776
2.pow(63, 5843009213693953).should eql 3103497645717974
2.pow(64, 5843009213693954).should eql 363986077738838
end
it "handles sign like #divmod does" do

22
spec/ruby/core/integer/round_spec.rb
Просмотреть файл

@ -63,18 +63,16 @@ describe "Integer#round" do
lambda { 42.round(obj) }.should raise_error(TypeError)
end
ruby_version_is "2.4" do
it "returns different rounded values depending on the half option" do
25.round(-1, half: :up).should eql(30)
25.round(-1, half: :down).should eql(20)
25.round(-1, half: :even).should eql(20)
35.round(-1, half: :up).should eql(40)
35.round(-1, half: :down).should eql(30)
35.round(-1, half: :even).should eql(40)
(-25).round(-1, half: :up).should eql(-30)
(-25).round(-1, half: :down).should eql(-20)
(-25).round(-1, half: :even).should eql(-20)
end
it "returns different rounded values depending on the half option" do
25.round(-1, half: :up).should eql(30)
25.round(-1, half: :down).should eql(20)
25.round(-1, half: :even).should eql(20)
35.round(-1, half: :up).should eql(40)
35.round(-1, half: :down).should eql(30)
35.round(-1, half: :even).should eql(40)
(-25).round(-1, half: :up).should eql(-30)
(-25).round(-1, half: :down).should eql(-20)
(-25).round(-1, half: :even).should eql(-20)
end
ruby_version_is "2.4"..."2.5" do

8
spec/ruby/core/integer/shared/integer_rounding.rb
Просмотреть файл

@ -5,11 +5,9 @@ describe :integer_rounding_positive_precision, shared: true do
end
end
ruby_version_is "2.4" do
it "returns self if passed a precision of zero" do
[2, -4, 10**70, -10**100].each do |v|
v.send(@method, 0).should eql(v)
end
it "returns self if passed a precision of zero" do
[2, -4, 10**70, -10**100].each do |v|
v.send(@method, 0).should eql(v)
end
end

18
spec/ruby/core/integer/truncate_spec.rb
Просмотреть файл

@ -6,16 +6,14 @@ describe "Integer#truncate" do
it_behaves_like :integer_to_i, :truncate
it_behaves_like :integer_rounding_positive_precision, :truncate
ruby_version_is "2.4" do
context "precision argument specified as part of the truncate method is negative" do
it "returns an integer with at least precision.abs trailing zeros" do
1832.truncate(-1).should eql(1830)
1832.truncate(-2).should eql(1800)
1832.truncate(-3).should eql(1000)
-1832.truncate(-1).should eql(-1830)
-1832.truncate(-2).should eql(-1800)
-1832.truncate(-3).should eql(-1000)
end
context "precision argument specified as part of the truncate method is negative" do
it "returns an integer with at least precision.abs trailing zeros" do
1832.truncate(-1).should eql(1830)
1832.truncate(-2).should eql(1800)
1832.truncate(-3).should eql(1000)
-1832.truncate(-1).should eql(-1830)
-1832.truncate(-2).should eql(-1800)
-1832.truncate(-3).should eql(-1000)
end
end
end

8
spec/ruby/core/io/gets_spec.rb
Просмотреть файл

@ -139,11 +139,9 @@ describe "IO#gets" do
end
end
ruby_version_is "2.4" do
describe "when passed chomp" do
it "returns the first line without a trailing newline character" do
@io.gets(chomp: true).should == IOSpecs.lines_without_newline_characters[0]
end
describe "when passed chomp" do
it "returns the first line without a trailing newline character" do
@io.gets(chomp: true).should == IOSpecs.lines_without_newline_characters[0]
end
end
end

8
spec/ruby/core/io/readline_spec.rb
Просмотреть файл

@ -43,11 +43,9 @@ describe "IO#readline" do
end
end
ruby_version_is "2.4" do
describe "when passed chomp" do
it "returns the first line without a trailing newline character" do
@io.readline(chomp: true).should == IOSpecs.lines_without_newline_characters[0]
end
describe "when passed chomp" do
it "returns the first line without a trailing newline character" do
@io.readline(chomp: true).should == IOSpecs.lines_without_newline_characters[0]
end
end
end

10
spec/ruby/core/io/shared/each.rb
Просмотреть файл

@ -156,12 +156,10 @@ describe :io_each, shared: true do
end
end
ruby_version_is "2.4" do
describe "when passed chomp" do
it "yields each line without trailing newline characters to the passed block" do
@io.send(@method, chomp: true) { |s| ScratchPad << s }
ScratchPad.recorded.should == IOSpecs.lines_without_newline_characters
end
describe "when passed chomp" do
it "yields each line without trailing newline characters to the passed block" do
@io.send(@method, chomp: true) { |s| ScratchPad << s }
ScratchPad.recorded.should == IOSpecs.lines_without_newline_characters
end
end
end

8
spec/ruby/core/io/shared/readlines.rb
Просмотреть файл

@ -18,11 +18,9 @@ describe :io_readlines, shared: true do
(result ? result : ScratchPad.recorded).should == IOSpecs.lines_empty_separator
end
ruby_version_is "2.4" do
it "yields a sequence of lines without trailing newline characters when chomp is passed" do
result = IO.send(@method, @name, chomp: true, &@object)
(result ? result : ScratchPad.recorded).should == IOSpecs.lines_without_newline_characters
end
it "yields a sequence of lines without trailing newline characters when chomp is passed" do
result = IO.send(@method, @name, chomp: true, &@object)
(result ? result : ScratchPad.recorded).should == IOSpecs.lines_without_newline_characters
end
end

12
spec/ruby/core/kernel/Complex_spec.rb
Просмотреть файл

@ -175,13 +175,11 @@ describe "Kernel.Complex()" do
end
end
ruby_bug "#15525", "2.6"..."2.6.1" do
describe "and nil arguments" do
it "swallows an error" do
Complex(nil, exception: false).should == nil
Complex(0, nil, exception: false).should == nil
Complex(nil, 0, exception: false).should == nil
end
describe "and nil arguments" do
it "swallows an error" do
Complex(nil, exception: false).should == nil
Complex(0, nil, exception: false).should == nil
Complex(nil, 0, exception: false).should == nil
end
end
end

16
spec/ruby/core/kernel/Integer_spec.rb
Просмотреть файл

@ -125,17 +125,15 @@ describe :kernel_integer, shared: true do
end
end
ruby_bug "#15525", "2.6"..."2.6.1" do
describe "and passed NaN" do
it "swallows an error" do
Integer(nan_value, exception: false).should == nil
end
describe "and passed NaN" do
it "swallows an error" do
Integer(nan_value, exception: false).should == nil
end
end
describe "and passed Infinity" do
it "swallows an error" do
Integer(infinity_value, exception: false).should == nil
end
describe "and passed Infinity" do
it "swallows an error" do
Integer(infinity_value, exception: false).should == nil
end
end

14
spec/ruby/core/kernel/clone_spec.rb
Просмотреть файл

@ -37,14 +37,12 @@ describe "Kernel#clone" do
o3.frozen?.should == true
end
ruby_version_is '2.4' do
it 'takes an option to copy freeze state or not' do
@obj.clone(freeze: true).frozen?.should == false
@obj.clone(freeze: false).frozen?.should == false
@obj.freeze
@obj.clone(freeze: true).frozen?.should == true
@obj.clone(freeze: false).frozen?.should == false
end
it 'takes an option to copy freeze state or not' do
@obj.clone(freeze: true).frozen?.should == false
@obj.clone(freeze: false).frozen?.should == false
@obj.freeze
@obj.clone(freeze: true).frozen?.should == true
@obj.clone(freeze: false).frozen?.should == false
end
it "copies instance variables" do

50
spec/ruby/core/kernel/shared/dup_clone.rb
Просмотреть файл

@ -79,48 +79,24 @@ describe :kernel_dup_clone, shared: true do
o3.untrusted?.should == true
end
ruby_version_is ''...'2.4' do
it "raises a TypeError for NilClass" do
lambda { nil.send(@method) }.should raise_error(TypeError)
end
it "raises a TypeError for TrueClass" do
lambda { true.send(@method) }.should raise_error(TypeError)
end
it "raises a TypeError for FalseClass" do
lambda { false.send(@method) }.should raise_error(TypeError)
end
it "raises a TypeError for Fixnum" do
lambda { 1.send(@method) }.should raise_error(TypeError)
end
it "raises a TypeError for Symbol" do
lambda { :my_symbol.send(@method) }.should raise_error(TypeError)
end
it "returns nil for NilClass" do
nil.send(@method).should == nil
end
ruby_version_is '2.4' do
it "returns nil for NilClass" do
nil.send(@method).should == nil
end
it "returns true for TrueClass" do
true.send(@method).should == true
end
it "returns true for TrueClass" do
true.send(@method).should == true
end
it "returns false for FalseClass" do
false.send(@method).should == false
end
it "returns false for FalseClass" do
false.send(@method).should == false
end
it "returns the same Integer for Integer" do
1.send(@method).should == 1
end
it "returns the same Integer for Integer" do
1.send(@method).should == 1
end
it "returns the same Symbol for Symbol" do
:my_symbol.send(@method).should == :my_symbol
end
it "returns the same Symbol for Symbol" do
:my_symbol.send(@method).should == :my_symbol
end
ruby_version_is ''...'2.5' do

9
spec/ruby/core/kernel/shared/require.rb
Просмотреть файл

@ -553,6 +553,15 @@ describe :kernel_require, shared: true do
required = ruby_exe(code, options: '--disable-gems')
required.should == "false\n" * provided.size
end
it "unicode_normalize is part of core and not $LOADED_FEATURES" do
features = ruby_exe("puts $LOADED_FEATURES", options: '--disable-gems')
features.lines.each { |feature|
feature.should_not include("unicode_normalize")
}
-> { @object.require("unicode_normalize") }.should raise_error(LoadError)
end
end
end

14
spec/ruby/core/kernel/warn_spec.rb
Просмотреть файл

@ -101,11 +101,9 @@ describe "Kernel#warn" do
-> { w.f4("foo", 3) }.should output(nil, %r|core/kernel/fixtures/classes.rb:#{w.f3_call_lineno}: warning: foo|)
end
ruby_bug "#14846", "2.5"..."2.6" do
it "does not prepend caller information if line number is too big" do
w = KernelSpecs::WarnInNestedCall.new
-> { w.f4("foo", 100) }.should output(nil, "warning: foo\n")
end
it "does not prepend caller information if line number is too big" do
w = KernelSpecs::WarnInNestedCall.new
-> { w.f4("foo", 100) }.should output(nil, "warning: foo\n")
end
it "prepends even if a message is empty or nil" do
@ -127,10 +125,8 @@ describe "Kernel#warn" do
-> { warn "", uplevel: -100 }.should raise_error(ArgumentError)
end
ruby_bug "#14846", "2.5"..."2.6" do
it "raises ArgumentError if passed -1" do
-> { warn "", uplevel: -1 }.should raise_error(ArgumentError)
end
it "raises ArgumentError if passed -1" do
-> { warn "", uplevel: -1 }.should raise_error(ArgumentError)
end
it "raises TypeError if passed not Integer" do

20
spec/ruby/core/matchdata/named_captures_spec.rb
Просмотреть файл

@ -1,17 +1,15 @@
require_relative '../../spec_helper'
ruby_version_is '2.4' do
describe 'MatchData#named_captures' do
it 'returns a Hash that has captured name and the matched string pairs' do
/(?<a>.)(?<b>.)?/.match('0').named_captures.should == { 'a' => '0', 'b' => nil }
end
describe 'MatchData#named_captures' do
it 'returns a Hash that has captured name and the matched string pairs' do
/(?<a>.)(?<b>.)?/.match('0').named_captures.should == { 'a' => '0', 'b' => nil }
end
it 'prefers later captures' do
/\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)\z/.match('0123').named_captures.should == { 'a' => '3', 'b' => '2' }
end
it 'prefers later captures' do
/\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)\z/.match('0123').named_captures.should == { 'a' => '3', 'b' => '2' }
end
it 'returns the latest matched capture, even if a later one that does not match exists' do
/\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)?\z/.match('012').named_captures.should == { 'a' => '0', 'b' => '2' }
end
it 'returns the latest matched capture, even if a later one that does not match exists' do
/\A(?<a>.)(?<b>.)(?<b>.)(?<a>.)?\z/.match('012').named_captures.should == { 'a' => '0', 'b' => '2' }
end
end

12
spec/ruby/core/matchdata/values_at_spec.rb
Просмотреть файл

@ -11,13 +11,11 @@ describe "MatchData#values_at" do
end
end
ruby_version_is '2.4' do
it 'slices captures with the given names' do
/(?<a>.)(?<b>.)(?<c>.)/.match('012').values_at(:c, :a).should == ['2', '0']
end
it 'slices captures with the given names' do
/(?<a>.)(?<b>.)(?<c>.)/.match('012').values_at(:c, :a).should == ['2', '0']
end
it 'takes names and indices' do
/\A(?<a>.)(?<b>.)\z/.match('01').values_at(0, 1, 2, :a, :b).should == ['01', '0', '1', '0', '1']
end
it 'takes names and indices' do
/\A(?<a>.)(?<b>.)\z/.match('01').values_at(0, 1, 2, :a, :b).should == ['01', '0', '1', '0', '1']
end
end

6
spec/ruby/core/math/lgamma_spec.rb
Просмотреть файл

@ -11,10 +11,8 @@ describe "Math.lgamma" do
end
end
ruby_version_is "2.4" do
it "returns [Infinity, -1] when passed -0.0" do
Math.lgamma(-0.0).should == [infinity_value, -1]
end
it "returns [Infinity, -1] when passed -0.0" do
Math.lgamma(-0.0).should == [infinity_value, -1]
end
it "returns [log(sqrt(PI)), 1] when passed 0.5" do

18
spec/ruby/core/method/parameters_spec.rb
Просмотреть файл

@ -243,17 +243,19 @@ describe "Method#parameters" do
end
it "returns [[:rest]] for core methods with variable-length argument lists" do
m = "foo"
# delete! takes rest args
"foo".method(:delete!).parameters.should == [[:rest]]
end
# match takes rest args
m.method(:match).parameters.should == [[:rest]]
# [] takes 1 to 3 args
m.method(:[]).parameters.should == [[:rest]]
it "returns [[:rest]] or [[:opt]] for core methods with optional arguments" do
# pop takes 1 optional argument
[
[[:rest]],
[[:opt]]
].should include([].method(:pop).parameters)
end
it "returns [[:req]] for each parameter for core methods with fixed-length argument lists" do
m = "foo"
m.method(:+).parameters.should == [[:req]]
"foo".method(:+).parameters.should == [[:req]]
end
end

24
spec/ruby/core/module/include_spec.rb
Просмотреть файл

@ -165,24 +165,12 @@ describe "Module#include" do
}.should raise_error(ArgumentError)
end
ruby_version_is ''...'2.4' do
it "accepts no-arguments" do
lambda {
Module.new do
include
end
}.should_not raise_error
end
end
ruby_version_is '2.4' do
it "doesn't accept no-arguments" do
lambda {
Module.new do
include
end
}.should raise_error(ArgumentError)
end
it "doesn't accept no-arguments" do
lambda {
Module.new do
include
end
}.should raise_error(ArgumentError)
end
it "returns the class it's included into" do

24
spec/ruby/core/module/prepend_spec.rb
Просмотреть файл

@ -231,24 +231,12 @@ describe "Module#prepend" do
}.should raise_error(ArgumentError)
end
ruby_version_is ''...'2.4' do
it "accepts no-arguments" do
lambda {
Module.new do
prepend
end
}.should_not raise_error
end
end
ruby_version_is '2.4' do
it "doesn't accept no-arguments" do
lambda {
Module.new do
prepend
end
}.should raise_error(ArgumentError)
end
it "doesn't accept no-arguments" do
lambda {
Module.new do
prepend
end
}.should raise_error(ArgumentError)
end
it "returns the class it's included into" do

66
spec/ruby/core/module/private_spec.rb
Просмотреть файл

@ -52,44 +52,42 @@ describe "Module#private" do
end.should raise_error(NameError)
end
ruby_bug "#14604", ""..."2.5.1" do
it "only makes the method private in the class it is called on" do
base = Class.new do
def wrapped
1
end
it "only makes the method private in the class it is called on" do
base = Class.new do
def wrapped
1
end
klass = Class.new(base) do
def wrapped
super + 1
end
private :wrapped
end
base.new.wrapped.should == 1
lambda do
klass.new.wrapped
end.should raise_error(NameError)
end
it "continues to allow a prepended module method to call super" do
wrapper = Module.new do
def wrapped
super + 1
end
klass = Class.new(base) do
def wrapped
super + 1
end
klass = Class.new do
prepend wrapper
def wrapped
1
end
private :wrapped
end
klass.new.wrapped.should == 2
private :wrapped
end
base.new.wrapped.should == 1
lambda do
klass.new.wrapped
end.should raise_error(NameError)
end
it "continues to allow a prepended module method to call super" do
wrapper = Module.new do
def wrapped
super + 1
end
end
klass = Class.new do
prepend wrapper
def wrapped
1
end
private :wrapped
end
klass.new.wrapped.should == 2
end
end

148
spec/ruby/core/module/refine_spec.rb
Просмотреть файл

@ -74,29 +74,17 @@ describe "Module#refine" do
end.should raise_error(TypeError)
end
ruby_version_is "" ... "2.4" do
it "raises TypeError if passed a module" do
lambda do
Module.new do
refine(Enumerable) {}
end
end.should raise_error(TypeError)
end
end
ruby_version_is "2.4" do
it "accepts a module as argument" do
inner_self = nil
Module.new do
refine(Enumerable) do
def blah
end
inner_self = self
it "accepts a module as argument" do
inner_self = nil
Module.new do
refine(Enumerable) do
def blah
end
inner_self = self
end
inner_self.public_instance_methods.should include(:blah)
end
inner_self.public_instance_methods.should include(:blah)
end
it "raises ArgumentError if not given a block" do
@ -319,108 +307,54 @@ describe "Module#refine" do
end
context "for methods accessed indirectly" do
ruby_version_is "" ... "2.4" do
it "is not honored by Kernel#send" do
refinement = Module.new do
refine ModuleSpecs::ClassWithFoo do
def foo; "foo from refinement"; end
end
it "is honored by Kernel#send" do
refinement = Module.new do
refine ModuleSpecs::ClassWithFoo do
def foo; "foo from refinement"; end
end
result = nil
Module.new do
using refinement
result = ModuleSpecs::ClassWithFoo.new.send :foo
end
result.should == "foo"
end
it "is not honored by BasicObject#__send__" do
refinement = Module.new do
refine ModuleSpecs::ClassWithFoo do
def foo; "foo from refinement"; end
end
end
result = nil
Module.new do
using refinement
result = ModuleSpecs::ClassWithFoo.new.__send__ :foo
end
result.should == "foo"
result = nil
Module.new do
using refinement
result = ModuleSpecs::ClassWithFoo.new.send :foo
end
it "is not honored by Symbol#to_proc" do
refinement = Module.new do
refine Integer do
def to_s
"(#{super})"
end
end
end
result = nil
Module.new do
using refinement
result = [1, 2, 3].map(&:to_s)
end
result.should == ["1", "2", "3"]
end
result.should == "foo from refinement"
end
ruby_version_is "2.4" do
it "is honored by Kernel#send" do
refinement = Module.new do
refine ModuleSpecs::ClassWithFoo do
def foo; "foo from refinement"; end
end
it "is honored by BasicObject#__send__" do
refinement = Module.new do
refine ModuleSpecs::ClassWithFoo do
def foo; "foo from refinement"; end
end
result = nil
Module.new do
using refinement
result = ModuleSpecs::ClassWithFoo.new.send :foo
end
result.should == "foo from refinement"
end
it "is honored by BasicObject#__send__" do
refinement = Module.new do
refine ModuleSpecs::ClassWithFoo do
def foo; "foo from refinement"; end
end
end
result = nil
Module.new do
using refinement
result = ModuleSpecs::ClassWithFoo.new.__send__ :foo
end
result.should == "foo from refinement"
result = nil
Module.new do
using refinement
result = ModuleSpecs::ClassWithFoo.new.__send__ :foo
end
it "is honored by Symbol#to_proc" do
refinement = Module.new do
refine Integer do
def to_s
"(#{super})"
end
result.should == "foo from refinement"
end
it "is honored by Symbol#to_proc" do
refinement = Module.new do
refine Integer do
def to_s
"(#{super})"
end
end
result = nil
Module.new do
using refinement
result = [1, 2, 3].map(&:to_s)
end
result.should == ["(1)", "(2)", "(3)"]
end
result = nil
Module.new do
using refinement
result = [1, 2, 3].map(&:to_s)
end
result.should == ["(1)", "(2)", "(3)"]
end
ruby_version_is "" ... "2.6" do

8
spec/ruby/core/nil/dup_spec.rb
Просмотреть файл

@ -1,9 +1,7 @@
require_relative '../../spec_helper'
ruby_version_is '2.4' do
describe "NilClass#dup" do
it "returns self" do
nil.dup.should equal(nil)
end
describe "NilClass#dup" do
it "returns self" do
nil.dup.should equal(nil)
end
end

10
spec/ruby/core/numeric/finite_spec.rb
Просмотреть файл

@ -1,10 +1,8 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Numeric#finite?" do
it "returns true by default" do
o = mock_numeric("finite")
o.finite?.should be_true
end
describe "Numeric#finite?" do
it "returns true by default" do
o = mock_numeric("finite")
o.finite?.should be_true
end
end

10
spec/ruby/core/numeric/infinite_spec.rb
Просмотреть файл

@ -1,10 +1,8 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "Numeric#infinite?" do
it "returns nil by default" do
o = mock_numeric("infinite")
o.infinite?.should == nil
end
describe "Numeric#infinite?" do
it "returns nil by default" do
o = mock_numeric("infinite")
o.infinite?.should == nil
end
end

6
spec/ruby/core/numeric/shared/step.rb
Просмотреть файл

@ -224,9 +224,6 @@ describe :numeric_step, :shared => true do
describe "when step is a String" do
error = nil
ruby_version_is ""..."2.4" do
error = ArgumentError
end
ruby_version_is "2.4"..."2.5" do
error = TypeError
end
@ -305,9 +302,6 @@ describe :numeric_step, :shared => true do
describe "size" do
describe "when step is a String" do
error = nil
ruby_version_is ""..."2.4" do
error = ArgumentError
end
ruby_version_is "2.4"..."2.5" do
error = TypeError
end

1
spec/ruby/core/objectspace/each_object_spec.rb
Просмотреть файл

@ -201,7 +201,6 @@ describe "ObjectSpace.each_object" do
expected = [ a, b, c, d ]
# singleton classes should be walked only on >= 2.3
expected << c_sclass
c_sclass.should be_kind_of(a.singleton_class)

14
spec/ruby/core/proc/element_reference_spec.rb
Просмотреть файл

@ -17,13 +17,11 @@ describe "Proc#call on a Proc created with Kernel#lambda or Kernel#proc" do
it_behaves_like :proc_call_on_proc_or_lambda, :call
end
ruby_bug "#15118", ""..."2.6" do
describe "Proc#[] with frozen_string_literals" do
it "doesn't duplicate frozen strings" do
ProcArefSpecs.aref.frozen?.should be_false
ProcArefSpecs.aref_freeze.frozen?.should be_true
ProcArefFrozenSpecs.aref.frozen?.should be_true
ProcArefFrozenSpecs.aref_freeze.frozen?.should be_true
end
describe "Proc#[] with frozen_string_literals" do
it "doesn't duplicate frozen strings" do
ProcArefSpecs.aref.frozen?.should be_false
ProcArefSpecs.aref_freeze.frozen?.should be_true
ProcArefFrozenSpecs.aref.frozen?.should be_true
ProcArefFrozenSpecs.aref_freeze.frozen?.should be_true
end
end

55
spec/ruby/core/process/clock_getres_spec.rb Normal file
Просмотреть файл

@ -0,0 +1,55 @@
require_relative '../../spec_helper'
require_relative 'fixtures/clocks'
describe "Process.clock_getres" do
ProcessSpecs.clock_constants.each do |name, value|
it "matches the clock in practice for Process::#{name}" do
times = []
10_000.times do
times << Process.clock_gettime(value, :nanosecond)
end
reported = Process.clock_getres(value, :nanosecond)
# The clock should not be more accurate than reported (times should be
# a multiple of reported precision.)
times.select { |t| t % reported > 0 }.should be_empty
# We're assuming precision is a multiple of ten - it may or may not
# be an incompatibility if it isn't but we'd like to notice this,
# and the spec following these wouldn't work if it isn't.
reported.should > 0
(reported == 1 || reported % 10 == 0).should be_true
# The clock should not be less accurate than reported (times should
# not all be a multiple of the next precision up, assuming precisions
# are multiples of ten.)
times.select { |t| t % (reported * 10) == 0 }.size.should_not == times.size
end
end
# These are documented
it "with :GETTIMEOFDAY_BASED_CLOCK_REALTIME reports 1 microsecond" do
Process.clock_getres(:GETTIMEOFDAY_BASED_CLOCK_REALTIME, :nanosecond).should == 1_000
end
it "with :TIME_BASED_CLOCK_REALTIME reports 1 second" do
Process.clock_getres(:TIME_BASED_CLOCK_REALTIME, :nanosecond).should == 1_000_000_000
end
platform_is_not :windows do
it "with :GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID reports 1 microsecond" do
Process.clock_getres(:GETRUSAGE_BASED_CLOCK_PROCESS_CPUTIME_ID, :nanosecond).should == 1_000
end
end
# These are observed
it "with Process::CLOCK_REALTIME reports at least 1 microsecond" do
Process.clock_getres(Process::CLOCK_REALTIME, :nanosecond).should <= 1_000
end
it "with Process::CLOCK_MONOTONIC reports at least 1 microsecond" do
Process.clock_getres(Process::CLOCK_MONOTONIC, :nanosecond).should <= 1_000
end
end

22
spec/ruby/core/process/clock_gettime_spec.rb
Просмотреть файл

@ -1,18 +1,10 @@
require_relative '../../spec_helper'
require_relative 'fixtures/clocks'
describe "Process.clock_gettime" do
platform_is_not :windows, :solaris do
Process.constants.select { |c|
c.to_s.start_with?('CLOCK_') &&
# These require CAP_WAKE_ALARM and are not documented in clock_gettime(),
# they return EINVAL if the permission is not granted.
c != :CLOCK_BOOTTIME_ALARM &&
c != :CLOCK_REALTIME_ALARM
}.each do |c|
it "can be called with Process::#{c}" do
value = Process.const_get(c)
Process.clock_gettime(value).should be_an_instance_of(Float)
end
ProcessSpecs.clock_constants.each do |name, value|
it "can be called with Process::#{name}" do
Process.clock_gettime(value).should be_an_instance_of(Float)
end
end
@ -36,7 +28,8 @@ describe "Process.clock_gettime" do
t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second)
t1.should be_an_instance_of(Float)
t2.should be_close(t1, 2.0) # 2.0 is chosen arbitrarily to allow for time skew without admitting failure cases, which would be off by an order of magnitude.
t2.should be_an_instance_of(Float)
t2.should be_close(t1, TIME_TOLERANCE)
end
it 'uses the default time unit (:float_second) when passed nil' do
@ -44,7 +37,8 @@ describe "Process.clock_gettime" do
t2 = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second)
t1.should be_an_instance_of(Float)
t2.should be_close(t1, 2.0) # 2.0 is chosen arbitrarily to allow for time skew without admitting failure cases, which would be off by an order of magnitude.
t2.should be_an_instance_of(Float)
t2.should be_close(t1, TIME_TOLERANCE)
end
end
end

24
spec/ruby/core/process/fixtures/clocks.rb Normal file
Просмотреть файл

@ -0,0 +1,24 @@
module ProcessSpecs
def self.clock_constants
clocks = []
platform_is_not :windows, :solaris do
clocks += Process.constants.select { |c| c.to_s.start_with?('CLOCK_') }
# These require CAP_WAKE_ALARM and are not documented in
# Process#clock_gettime they return EINVAL if the permission
# is not granted.
clocks -= [:CLOCK_BOOTTIME_ALARM, :CLOCK_REALTIME_ALARM]
# These clocks in practice on Linux do not seem to match
# their reported resolution.
clocks -= [:CLOCK_REALTIME_COARSE, :CLOCK_MONOTONIC_COARSE]
clocks.map! { |c|
[c, Process.const_get(c)]
}
end
clocks
end
end

6
spec/ruby/core/process/wait2_spec.rb
Просмотреть файл

@ -13,10 +13,8 @@ describe "Process.wait2" do
end
leaked = Process.waitall
$stderr.puts "leaked before wait2 specs: #{leaked}" unless leaked.empty?
with_feature :mjit do
# Ruby-space should not see PIDs used by mjit
leaked.should be_empty
end
# Ruby-space should not see PIDs used by mjit
leaked.should be_empty
rescue Errno::ECHILD # No child processes
rescue NotImplementedError
end

6
spec/ruby/core/process/wait_spec.rb
Просмотреть файл

@ -8,10 +8,8 @@ describe "Process.wait" do
begin
leaked = Process.waitall
puts "leaked before wait specs: #{leaked}" unless leaked.empty?
with_feature :mjit do
# Ruby-space should not see PIDs used by mjit
leaked.should be_empty
end
# Ruby-space should not see PIDs used by mjit
leaked.should be_empty
rescue NotImplementedError
end
end

1
spec/ruby/core/rational/round_spec.rb
Просмотреть файл

@ -1,3 +1,4 @@
require_relative '../../spec_helper'
require_relative '../../shared/rational/round'
describe "Rational#round" do

40
spec/ruby/core/regexp/match_spec.rb
Просмотреть файл

@ -111,32 +111,30 @@ describe "Regexp#match" do
end
end
ruby_version_is "2.4" do
describe "Regexp#match?" do
before :each do
# Resetting Regexp.last_match
/DONTMATCH/.match ''
end
describe "Regexp#match?" do
before :each do
# Resetting Regexp.last_match
/DONTMATCH/.match ''
end
context "when matches the given value" do
it "returns true but does not set Regexp.last_match" do
/string/i.match?('string').should be_true
Regexp.last_match.should be_nil
end
context "when matches the given value" do
it "returns true but does not set Regexp.last_match" do
/string/i.match?('string').should be_true
Regexp.last_match.should be_nil
end
end
it "returns false when does not match the given value" do
/STRING/.match?('string').should be_false
end
it "returns false when does not match the given value" do
/STRING/.match?('string').should be_false
end
it "takes matching position as the 2nd argument" do
/str/i.match?('string', 0).should be_true
/str/i.match?('string', 1).should be_false
end
it "takes matching position as the 2nd argument" do
/str/i.match?('string', 0).should be_true
/str/i.match?('string', 1).should be_false
end
it "returns false when given nil" do
/./.match?(nil).should be_false
end
it "returns false when given nil" do
/./.match?(nil).should be_false
end
end

222
spec/ruby/core/string/capitalize_spec.rb
Просмотреть файл

@ -17,75 +17,65 @@ describe "String#capitalize" do
"hello".taint.capitalize.tainted?.should == true
end
ruby_version_is ''...'2.4' do
it "is locale insensitive (only upcases a-z and only downcases A-Z)" do
"ÄÖÜ".capitalize.should == "ÄÖÜ"
"ärger".capitalize.should == "ärger"
"BÄR".capitalize.should == "BÄr"
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"äöÜ".capitalize.should == "Äöü"
end
it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do
"ß".capitalize.should == "Ss"
end
it "updates string metadata" do
capitalized = "ßeT".capitalize
capitalized.should == "Sset"
capitalized.size.should == 4
capitalized.bytesize.should == 4
capitalized.ascii_only?.should be_true
end
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"äöÜ".capitalize.should == "Äöü"
end
describe "ASCII-only case mapping" do
it "does not capitalize non-ASCII characters" do
"ßet".capitalize(:ascii).should == "ßet"
end
end
it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do
"ß".capitalize.should == "Ss"
end
it "updates string metadata" do
capitalized = "ßeT".capitalize
capitalized.should == "Sset"
capitalized.size.should == 4
capitalized.bytesize.should == 4
capitalized.ascii_only?.should be_true
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "capitalizes ASCII characters according to Turkic semantics" do
"iSa".capitalize(:turkic).should == "İsa"
end
describe "ASCII-only case mapping" do
it "does not capitalize non-ASCII characters" do
"ßet".capitalize(:ascii).should == "ßet"
end
it "allows Lithuanian as an extra option" do
"iSa".capitalize(:turkic, :lithuanian).should == "İsa"
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "capitalizes ASCII characters according to Turkic semantics" do
"iSa".capitalize(:turkic).should == "İsa"
end
it "does not allow any other additional option" do
lambda { "iSa".capitalize(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Lithuanian as an extra option" do
"iSa".capitalize(:turkic, :lithuanian).should == "İsa"
end
it "does not allow any other additional option" do
lambda { "iSa".capitalize(:turkic, :ascii) }.should raise_error(ArgumentError)
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"iß".capitalize(:lithuanian).should == "Iß"
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"iß".capitalize(:lithuanian).should == "Iß"
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"iß".capitalize(:lithuanian, :turkic).should == "İß"
end
it "does not allow any other additional option" do
lambda { "iß".capitalize(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"iß".capitalize(:lithuanian, :turkic).should == "İß"
end
it "does not allow the :fold option for upcasing" do
lambda { "abc".capitalize(:fold) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { "iß".capitalize(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow invalid options" do
lambda { "abc".capitalize(:invalid_option) }.should raise_error(ArgumentError)
end
it "does not allow the :fold option for upcasing" do
lambda { "abc".capitalize(:fold) }.should raise_error(ArgumentError)
end
it "does not allow invalid options" do
lambda { "abc".capitalize(:invalid_option) }.should raise_error(ArgumentError)
end
it "returns subclass instances when called on a subclass" do
@ -101,82 +91,80 @@ describe "String#capitalize!" do
a.should == "Hello"
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "äöÜ"
a.capitalize!
a.should == "Äöü"
end
it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do
a = "ß"
a.capitalize!
a.should == "Ss"
end
it "updates string metadata" do
capitalized = "ßeT"
capitalized.capitalize!
capitalized.should == "Sset"
capitalized.size.should == 4
capitalized.bytesize.should == 4
capitalized.ascii_only?.should be_true
end
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "äöÜ"
a.capitalize!
a.should == "Äöü"
end
describe "modifies self in place for ASCII-only case mapping" do
it "does not capitalize non-ASCII characters" do
a = "ßet"
a.capitalize!(:ascii)
a.should == "ßet"
end
it "only capitalizes the first resulting character when upcasing a character produces a multi-character sequence" do
a = "ß"
a.capitalize!
a.should == "Ss"
end
describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do
it "capitalizes ASCII characters according to Turkic semantics" do
a = "iSa"
a.capitalize!(:turkic)
a.should == "İsa"
end
it "updates string metadata" do
capitalized = "ßeT"
capitalized.capitalize!
it "allows Lithuanian as an extra option" do
a = "iSa"
a.capitalize!(:turkic, :lithuanian)
a.should == "İsa"
end
capitalized.should == "Sset"
capitalized.size.should == 4
capitalized.bytesize.should == 4
capitalized.ascii_only?.should be_true
end
end
it "does not allow any other additional option" do
lambda { a = "iSa"; a.capitalize!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
describe "modifies self in place for ASCII-only case mapping" do
it "does not capitalize non-ASCII characters" do
a = "ßet"
a.capitalize!(:ascii)
a.should == "ßet"
end
end
describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do
it "capitalizes ASCII characters according to Turkic semantics" do
a = "iSa"
a.capitalize!(:turkic)
a.should == "İsa"
end
describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "iß"
a.capitalize!(:lithuanian)
a.should == "Iß"
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "iß"
a.capitalize!(:lithuanian, :turkic)
a.should == "İß"
end
it "does not allow any other additional option" do
lambda { a = "iß"; a.capitalize!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
it "allows Lithuanian as an extra option" do
a = "iSa"
a.capitalize!(:turkic, :lithuanian)
a.should == "İsa"
end
it "does not allow the :fold option for upcasing" do
lambda { a = "abc"; a.capitalize!(:fold) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { a = "iSa"; a.capitalize!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "iß"
a.capitalize!(:lithuanian)
a.should == "Iß"
end
it "does not allow invalid options" do
lambda { a = "abc"; a.capitalize!(:invalid_option) }.should raise_error(ArgumentError)
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "iß"
a.capitalize!(:lithuanian, :turkic)
a.should == "İß"
end
it "does not allow any other additional option" do
lambda { a = "iß"; a.capitalize!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow the :fold option for upcasing" do
lambda { a = "abc"; a.capitalize!(:fold) }.should raise_error(ArgumentError)
end
it "does not allow invalid options" do
lambda { a = "abc"; a.capitalize!(:invalid_option) }.should raise_error(ArgumentError)
end
it "returns nil when no changes are made" do

140
spec/ruby/core/string/casecmp_spec.rb
Просмотреть файл

@ -101,10 +101,8 @@ describe "String#casecmp independent of case" do
@lower_a_tilde.casecmp(@upper_a_tilde).should == 1
end
ruby_version_is "2.4" do
it "does not case fold" do
"ß".casecmp("ss").should == 1
end
it "does not case fold" do
"ß".casecmp("ss").should == 1
end
end
@ -129,88 +127,84 @@ describe "String#casecmp independent of case" do
end
end
ruby_version_is "2.4" do
describe 'String#casecmp? independent of case' do
describe 'String#casecmp? independent of case' do
it 'returns true when equal to other' do
'abc'.casecmp?('abc').should == true
'abc'.casecmp?('ABC').should == true
end
it 'returns false when not equal to other' do
'abc'.casecmp?('DEF').should == false
'abc'.casecmp?('def').should == false
end
it "tries to convert other to string using to_str" do
other = mock('x')
other.should_receive(:to_str).and_return("abc")
"abc".casecmp?(other).should == true
end
it "returns nil if incompatible encodings" do
"あれ".casecmp?("れ".encode(Encoding::EUC_JP)).should be_nil
end
describe 'for UNICODE characters' do
it 'returns true when downcase(:fold) on unicode' do
'äöü'.casecmp?('ÄÖÜ').should == true
end
end
describe "when comparing a subclass instance" do
it 'returns true when equal to other' do
'abc'.casecmp?('abc').should == true
'abc'.casecmp?('ABC').should == true
a = StringSpecs::MyString.new "a"
'a'.casecmp?(a).should == true
'A'.casecmp?(a).should == true
end
it 'returns false when not equal to other' do
'abc'.casecmp?('DEF').should == false
'abc'.casecmp?('def').should == false
b = StringSpecs::MyString.new "a"
'b'.casecmp?(b).should == false
'B'.casecmp?(b).should == false
end
end
it "tries to convert other to string using to_str" do
other = mock('x')
other.should_receive(:to_str).and_return("abc")
"abc".casecmp?(other).should == true
end
it "returns nil if incompatible encodings" do
"あれ".casecmp?("れ".encode(Encoding::EUC_JP)).should be_nil
end
describe 'for UNICODE characters' do
it 'returns true when downcase(:fold) on unicode' do
'äöü'.casecmp?('ÄÖÜ').should == true
end
end
describe "when comparing a subclass instance" do
it 'returns true when equal to other' do
a = StringSpecs::MyString.new "a"
'a'.casecmp?(a).should == true
'A'.casecmp?(a).should == true
describe "in UTF-8 mode" do
describe "for non-ASCII characters" do
before :each do
@upper_a_tilde = "Ã"
@lower_a_tilde = "ã"
@upper_a_umlaut = "Ä"
@lower_a_umlaut = "ä"
end
it 'returns false when not equal to other' do
b = StringSpecs::MyString.new "a"
'b'.casecmp?(b).should == false
'B'.casecmp?(b).should == false
it "returns true when they are the same with normalized case" do
@upper_a_tilde.casecmp?(@lower_a_tilde).should == true
end
end
describe "in UTF-8 mode" do
describe "for non-ASCII characters" do
before :each do
@upper_a_tilde = "Ã"
@lower_a_tilde = "ã"
@upper_a_umlaut = "Ä"
@lower_a_umlaut = "ä"
end
it "returns true when they are the same with normalized case" do
@upper_a_tilde.casecmp?(@lower_a_tilde).should == true
end
it "returns false when they are unrelated" do
@upper_a_tilde.casecmp?(@upper_a_umlaut).should == false
end
it "returns true when they have the same bytes" do
@upper_a_tilde.casecmp?(@upper_a_tilde).should == true
end
it "returns false when they are unrelated" do
@upper_a_tilde.casecmp?(@upper_a_umlaut).should == false
end
end
ruby_version_is "2.4" do
it "case folds" do
"ß".casecmp?("ss").should be_true
end
end
ruby_version_is "2.4" ... "2.5" do
it "raises a TypeError if other can't be converted to a string" do
lambda { "abc".casecmp?(mock('abc')) }.should raise_error(TypeError)
end
end
ruby_version_is "2.5" do
it "returns nil if other can't be converted to a string" do
"abc".casecmp?(mock('abc')).should be_nil
it "returns true when they have the same bytes" do
@upper_a_tilde.casecmp?(@upper_a_tilde).should == true
end
end
end
it "case folds" do
"ß".casecmp?("ss").should be_true
end
ruby_version_is "2.4"..."2.5" do
it "raises a TypeError if other can't be converted to a string" do
lambda { "abc".casecmp?(mock('abc')) }.should raise_error(TypeError)
end
end
ruby_version_is "2.5" do
it "returns nil if other can't be converted to a string" do
"abc".casecmp?(mock('abc')).should be_nil
end
end
end

30
spec/ruby/core/string/concat_spec.rb
Просмотреть файл

@ -6,23 +6,21 @@ describe "String#concat" do
it_behaves_like :string_concat, :concat
it_behaves_like :string_concat_encoding, :concat
ruby_version_is "2.4" do
it "takes multiple arguments" do
str = "hello "
str.concat "wo", "", "rld"
str.should == "hello world"
end
it "takes multiple arguments" do
str = "hello "
str.concat "wo", "", "rld"
str.should == "hello world"
end
it "concatenates the initial value when given arguments contain 2 self" do
str = "hello"
str.concat str, str
str.should == "hellohellohello"
end
it "concatenates the initial value when given arguments contain 2 self" do
str = "hello"
str.concat str, str
str.should == "hellohellohello"
end
it "returns self when given no arguments" do
str = "hello"
str.concat.should equal(str)
str.should == "hello"
end
it "returns self when given no arguments" do
str = "hello"
str.concat.should equal(str)
str.should == "hello"
end
end

224
spec/ruby/core/string/downcase_spec.rb
Просмотреть файл

@ -8,82 +8,66 @@ describe "String#downcase" do
"hello".downcase.should == "hello"
end
ruby_version_is ''...'2.4' do
it "is locale insensitive (only replaces A-Z)" do
"ÄÖÜ".downcase.should == "ÄÖÜ"
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"ÄÖÜ".downcase.should == "äöü"
end
str = Array.new(256) { |c| c.chr }.join
expected = Array.new(256) do |i|
c = i.chr
c.between?("A", "Z") ? c.downcase : c
end.join
it "updates string metadata" do
downcased = "\u{212A}ING".downcase
str.downcase.should == expected
downcased.should == "king"
downcased.size.should == 4
downcased.bytesize.should == 4
downcased.ascii_only?.should be_true
end
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"ÄÖÜ".downcase.should == "äöü"
end
describe "ASCII-only case mapping" do
it "does not downcase non-ASCII characters" do
"CÅR".downcase(:ascii).should == "cÅr"
end
end
it "updates string metadata" do
downcased = "\u{212A}ING".downcase
downcased.should == "king"
downcased.size.should == 4
downcased.bytesize.should == 4
downcased.ascii_only?.should be_true
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "downcases characters according to Turkic semantics" do
"İ".downcase(:turkic).should == "i"
end
describe "ASCII-only case mapping" do
it "does not downcase non-ASCII characters" do
"CÅR".downcase(:ascii).should == "cÅr"
end
it "allows Lithuanian as an extra option" do
"İ".downcase(:turkic, :lithuanian).should == "i"
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "downcases characters according to Turkic semantics" do
"İ".downcase(:turkic).should == "i"
end
it "does not allow any other additional option" do
lambda { "İ".downcase(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Lithuanian as an extra option" do
"İ".downcase(:turkic, :lithuanian).should == "i"
end
it "does not allow any other additional option" do
lambda { "İ".downcase(:turkic, :ascii) }.should raise_error(ArgumentError)
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"İS".downcase(:lithuanian).should == "i\u{307}s"
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"İS".downcase(:lithuanian).should == "i\u{307}s"
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"İS".downcase(:lithuanian, :turkic).should == "is"
end
it "does not allow any other additional option" do
lambda { "İS".downcase(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"İS".downcase(:lithuanian, :turkic).should == "is"
end
describe "case folding" do
it "case folds special characters" do
"ß".downcase.should == "ß"
"ß".downcase(:fold).should == "ss"
end
it "does not allow any other additional option" do
lambda { "İS".downcase(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow invalid options" do
lambda { "ABC".downcase(:invalid_option) }.should raise_error(ArgumentError)
describe "case folding" do
it "case folds special characters" do
"ß".downcase.should == "ß"
"ß".downcase(:fold).should == "ss"
end
end
it "does not allow invalid options" do
lambda { "ABC".downcase(:invalid_option) }.should raise_error(ArgumentError)
end
it "taints result when self is tainted" do
"".taint.downcase.tainted?.should == true
"x".taint.downcase.tainted?.should == true
@ -102,85 +86,83 @@ describe "String#downcase!" do
a.should == "hello"
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "ÄÖÜ"
a.downcase!
a.should == "äöü"
end
it "updates string metadata" do
downcased = "\u{212A}ING"
downcased.downcase!
downcased.should == "king"
downcased.size.should == 4
downcased.bytesize.should == 4
downcased.ascii_only?.should be_true
end
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "ÄÖÜ"
a.downcase!
a.should == "äöü"
end
describe "ASCII-only case mapping" do
it "does not downcase non-ASCII characters" do
a = "CÅR"
a.downcase!(:ascii)
a.should == "cÅr"
end
it "updates string metadata" do
downcased = "\u{212A}ING"
downcased.downcase!
downcased.should == "king"
downcased.size.should == 4
downcased.bytesize.should == 4
downcased.ascii_only?.should be_true
end
end
describe "ASCII-only case mapping" do
it "does not downcase non-ASCII characters" do
a = "CÅR"
a.downcase!(:ascii)
a.should == "cÅr"
end
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "downcases characters according to Turkic semantics" do
a = "İ"
a.downcase!(:turkic)
a.should == "i"
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "downcases characters according to Turkic semantics" do
a = "İ"
a.downcase!(:turkic)
a.should == "i"
end
it "allows Lithuanian as an extra option" do
a = "İ"
a.downcase!(:turkic, :lithuanian)
a.should == "i"
end
it "does not allow any other additional option" do
lambda { a = "İ"; a.downcase!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
it "allows Lithuanian as an extra option" do
a = "İ"
a.downcase!(:turkic, :lithuanian)
a.should == "i"
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "İS"
a.downcase!(:lithuanian)
a.should == "i\u{307}s"
end
it "does not allow any other additional option" do
lambda { a = "İ"; a.downcase!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "İS"
a.downcase!(:lithuanian, :turkic)
a.should == "is"
end
it "does not allow any other additional option" do
lambda { a = "İS"; a.downcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "İS"
a.downcase!(:lithuanian)
a.should == "i\u{307}s"
end
describe "case folding" do
it "case folds special characters" do
a = "ß"
a.downcase!
a.should == "ß"
a.downcase!(:fold)
a.should == "ss"
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "İS"
a.downcase!(:lithuanian, :turkic)
a.should == "is"
end
it "does not allow invalid options" do
lambda { a = "ABC"; a.downcase!(:invalid_option) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { a = "İS"; a.downcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
describe "case folding" do
it "case folds special characters" do
a = "ß"
a.downcase!
a.should == "ß"
a.downcase!(:fold)
a.should == "ss"
end
end
it "does not allow invalid options" do
lambda { a = "ABC"; a.downcase!(:invalid_option) }.should raise_error(ArgumentError)
end
it "returns nil if no modifications were made" do
a = "hello"
a.downcase!.should == nil

105
spec/ruby/core/string/dump_spec.rb
Просмотреть файл

@ -352,78 +352,39 @@ describe "String#dump" do
].should be_computed_by(:dump)
end
ruby_version_is ''...'2.4' do
it "returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with lower-case hex digits" do
[ [0200.chr('utf-8'), '"\u{80}"'],
[0201.chr('utf-8'), '"\u{81}"'],
[0202.chr('utf-8'), '"\u{82}"'],
[0203.chr('utf-8'), '"\u{83}"'],
[0204.chr('utf-8'), '"\u{84}"'],
[0206.chr('utf-8'), '"\u{86}"'],
[0207.chr('utf-8'), '"\u{87}"'],
[0210.chr('utf-8'), '"\u{88}"'],
[0211.chr('utf-8'), '"\u{89}"'],
[0212.chr('utf-8'), '"\u{8a}"'],
[0213.chr('utf-8'), '"\u{8b}"'],
[0214.chr('utf-8'), '"\u{8c}"'],
[0215.chr('utf-8'), '"\u{8d}"'],
[0216.chr('utf-8'), '"\u{8e}"'],
[0217.chr('utf-8'), '"\u{8f}"'],
[0220.chr('utf-8'), '"\u{90}"'],
[0221.chr('utf-8'), '"\u{91}"'],
[0222.chr('utf-8'), '"\u{92}"'],
[0223.chr('utf-8'), '"\u{93}"'],
[0224.chr('utf-8'), '"\u{94}"'],
[0225.chr('utf-8'), '"\u{95}"'],
[0226.chr('utf-8'), '"\u{96}"'],
[0227.chr('utf-8'), '"\u{97}"'],
[0230.chr('utf-8'), '"\u{98}"'],
[0231.chr('utf-8'), '"\u{99}"'],
[0232.chr('utf-8'), '"\u{9a}"'],
[0233.chr('utf-8'), '"\u{9b}"'],
[0234.chr('utf-8'), '"\u{9c}"'],
[0235.chr('utf-8'), '"\u{9d}"'],
[0236.chr('utf-8'), '"\u{9e}"'],
[0237.chr('utf-8'), '"\u{9f}"'],
].should be_computed_by(:dump)
end
end
ruby_version_is '2.4' do
it "returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with upper-case hex digits" do
[ [0200.chr('utf-8'), '"\u0080"'],
[0201.chr('utf-8'), '"\u0081"'],
[0202.chr('utf-8'), '"\u0082"'],
[0203.chr('utf-8'), '"\u0083"'],
[0204.chr('utf-8'), '"\u0084"'],
[0206.chr('utf-8'), '"\u0086"'],
[0207.chr('utf-8'), '"\u0087"'],
[0210.chr('utf-8'), '"\u0088"'],
[0211.chr('utf-8'), '"\u0089"'],
[0212.chr('utf-8'), '"\u008A"'],
[0213.chr('utf-8'), '"\u008B"'],
[0214.chr('utf-8'), '"\u008C"'],
[0215.chr('utf-8'), '"\u008D"'],
[0216.chr('utf-8'), '"\u008E"'],
[0217.chr('utf-8'), '"\u008F"'],
[0220.chr('utf-8'), '"\u0090"'],
[0221.chr('utf-8'), '"\u0091"'],
[0222.chr('utf-8'), '"\u0092"'],
[0223.chr('utf-8'), '"\u0093"'],
[0224.chr('utf-8'), '"\u0094"'],
[0225.chr('utf-8'), '"\u0095"'],
[0226.chr('utf-8'), '"\u0096"'],
[0227.chr('utf-8'), '"\u0097"'],
[0230.chr('utf-8'), '"\u0098"'],
[0231.chr('utf-8'), '"\u0099"'],
[0232.chr('utf-8'), '"\u009A"'],
[0233.chr('utf-8'), '"\u009B"'],
[0234.chr('utf-8'), '"\u009C"'],
[0235.chr('utf-8'), '"\u009D"'],
[0236.chr('utf-8'), '"\u009E"'],
[0237.chr('utf-8'), '"\u009F"'],
].should be_computed_by(:dump)
end
it "returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with upper-case hex digits" do
[ [0200.chr('utf-8'), '"\u0080"'],
[0201.chr('utf-8'), '"\u0081"'],
[0202.chr('utf-8'), '"\u0082"'],
[0203.chr('utf-8'), '"\u0083"'],
[0204.chr('utf-8'), '"\u0084"'],
[0206.chr('utf-8'), '"\u0086"'],
[0207.chr('utf-8'), '"\u0087"'],
[0210.chr('utf-8'), '"\u0088"'],
[0211.chr('utf-8'), '"\u0089"'],
[0212.chr('utf-8'), '"\u008A"'],
[0213.chr('utf-8'), '"\u008B"'],
[0214.chr('utf-8'), '"\u008C"'],
[0215.chr('utf-8'), '"\u008D"'],
[0216.chr('utf-8'), '"\u008E"'],
[0217.chr('utf-8'), '"\u008F"'],
[0220.chr('utf-8'), '"\u0090"'],
[0221.chr('utf-8'), '"\u0091"'],
[0222.chr('utf-8'), '"\u0092"'],
[0223.chr('utf-8'), '"\u0093"'],
[0224.chr('utf-8'), '"\u0094"'],
[0225.chr('utf-8'), '"\u0095"'],
[0226.chr('utf-8'), '"\u0096"'],
[0227.chr('utf-8'), '"\u0097"'],
[0230.chr('utf-8'), '"\u0098"'],
[0231.chr('utf-8'), '"\u0099"'],
[0232.chr('utf-8'), '"\u009A"'],
[0233.chr('utf-8'), '"\u009B"'],
[0234.chr('utf-8'), '"\u009C"'],
[0235.chr('utf-8'), '"\u009D"'],
[0236.chr('utf-8'), '"\u009E"'],
[0237.chr('utf-8'), '"\u009F"'],
].should be_computed_by(:dump)
end
it "includes .force_encoding(name) if the encoding isn't ASCII compatible" do

10
spec/ruby/core/string/lines_spec.rb
Просмотреть файл

@ -11,12 +11,10 @@ describe "String#lines" do
ary.should == ["hello ", "world"]
end
ruby_version_is '2.4' do
context "when `chomp` keyword argument is passed" do
it "removes new line characters" do
"hello \nworld\n".lines(chomp: true).should == ["hello ", "world"]
"hello \r\nworld\r\n".lines(chomp: true).should == ["hello ", "world"]
end
context "when `chomp` keyword argument is passed" do
it "removes new line characters" do
"hello \nworld\n".lines(chomp: true).should == ["hello ", "world"]
"hello \r\nworld\r\n".lines(chomp: true).should == ["hello ", "world"]
end
end
end

38
spec/ruby/core/string/match_spec.rb
Просмотреть файл

@ -149,27 +149,25 @@ describe "String#match" do
end
end
ruby_version_is "2.4" do
describe "String#match?" do
before :each do
# Resetting Regexp.last_match
/DONTMATCH/.match ''
end
describe "String#match?" do
before :each do
# Resetting Regexp.last_match
/DONTMATCH/.match ''
end
context "when matches the given regex" do
it "returns true but does not set Regexp.last_match" do
'string'.match?(/string/i).should be_true
Regexp.last_match.should be_nil
end
end
it "returns false when does not match the given regex" do
'string'.match?(/STRING/).should be_false
end
it "takes matching position as the 2nd argument" do
'string'.match?(/str/i, 0).should be_true
'string'.match?(/str/i, 1).should be_false
context "when matches the given regex" do
it "returns true but does not set Regexp.last_match" do
'string'.match?(/string/i).should be_true
Regexp.last_match.should be_nil
end
end
it "returns false when does not match the given regex" do
'string'.match?(/STRING/).should be_false
end
it "takes matching position as the 2nd argument" do
'string'.match?(/str/i, 0).should be_true
'string'.match?(/str/i, 1).should be_false
end
end

8
spec/ruby/core/string/new_spec.rb
Просмотреть файл

@ -13,11 +13,9 @@ describe "String.new" do
str.encoding.should == Encoding::EUC_JP
end
ruby_version_is "2.4" do
it "accepts a capacity argument" do
String.new("", capacity: 100_000).should == ""
String.new("abc", capacity: 100_000).should == "abc"
end
it "accepts a capacity argument" do
String.new("", capacity: 100_000).should == ""
String.new("abc", capacity: 100_000).should == "abc"
end
it "returns a fully-formed String" do

30
spec/ruby/core/string/prepend_spec.rb
Просмотреть файл

@ -42,23 +42,21 @@ describe "String#prepend" do
x.prepend("y".taint).tainted?.should be_true
end
ruby_version_is "2.4" do
it "takes multiple arguments" do
str = " world"
str.prepend "he", "", "llo"
str.should == "hello world"
end
it "takes multiple arguments" do
str = " world"
str.prepend "he", "", "llo"
str.should == "hello world"
end
it "prepends the initial value when given arguments contain 2 self" do
str = "hello"
str.prepend str, str
str.should == "hellohellohello"
end
it "prepends the initial value when given arguments contain 2 self" do
str = "hello"
str.prepend str, str
str.should == "hellohellohello"
end
it "returns self when given no arguments" do
str = "hello"
str.prepend.should equal(str)
str.should == "hello"
end
it "returns self when given no arguments" do
str = "hello"
str.prepend.should equal(str)
str.should == "hello"
end
end

46
spec/ruby/core/string/shared/each_line.rb
Просмотреть файл

@ -145,34 +145,32 @@ describe :string_each_line, shared: true do
lambda { "hello world".send(@method, :o).to_a }.should raise_error(TypeError)
end
ruby_version_is '2.4' do
context "when `chomp` keyword argument is passed" do
it "removes new line characters when separator is not specified" do
a = []
"hello \nworld\n".send(@method, chomp: true) { |s| a << s }
a.should == ["hello ", "world"]
context "when `chomp` keyword argument is passed" do
it "removes new line characters when separator is not specified" do
a = []
"hello \nworld\n".send(@method, chomp: true) { |s| a << s }
a.should == ["hello ", "world"]
a = []
"hello \r\nworld\r\n".send(@method, chomp: true) { |s| a << s }
a.should == ["hello ", "world"]
end
a = []
"hello \r\nworld\r\n".send(@method, chomp: true) { |s| a << s }
a.should == ["hello ", "world"]
end
it "removes only specified separator" do
a = []
"hello world".send(@method, ' ', chomp: true) { |s| a << s }
a.should == ["hello", "world"]
end
it "removes only specified separator" do
a = []
"hello world".send(@method, ' ', chomp: true) { |s| a << s }
a.should == ["hello", "world"]
end
# https://bugs.ruby-lang.org/issues/14257
it "ignores new line characters when separator is specified" do
a = []
"hello\n world\n".send(@method, ' ', chomp: true) { |s| a << s }
a.should == ["hello\n", "world\n"]
# https://bugs.ruby-lang.org/issues/14257
it "ignores new line characters when separator is specified" do
a = []
"hello\n world\n".send(@method, ' ', chomp: true) { |s| a << s }
a.should == ["hello\n", "world\n"]
a = []
"hello\r\n world\r\n".send(@method, ' ', chomp: true) { |s| a << s }
a.should == ["hello\r\n", "world\r\n"]
end
a = []
"hello\r\n world\r\n".send(@method, ' ', chomp: true) { |s| a << s }
a.should == ["hello\r\n", "world\r\n"]
end
end
end

60
spec/ruby/core/string/split_spec.rb
Просмотреть файл

@ -65,28 +65,26 @@ describe "String#split with String" do
end
it "defaults to $; when string isn't given or nil" do
begin
verbose = $VERBOSE
$VERBOSE = nil
suppress_warning do
old_fs = $;
begin
[",", ":", "", "XY", nil].each do |fs|
$; = fs
[",", ":", "", "XY", nil].each do |fs|
$; = fs
["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str|
expected = str.split(fs || " ")
["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str|
expected = str.split(fs || " ")
str.split(nil).should == expected
str.split.should == expected
str.split(nil).should == expected
str.split.should == expected
str.split(nil, -1).should == str.split(fs || " ", -1)
str.split(nil, 0).should == str.split(fs || " ", 0)
str.split(nil, 2).should == str.split(fs || " ", 2)
str.split(nil, -1).should == str.split(fs || " ", -1)
str.split(nil, 0).should == str.split(fs || " ", 0)
str.split(nil, 2).should == str.split(fs || " ", 2)
end
end
ensure
$; = old_fs
end
ensure
$; = old_fs
$VERBOSE = verbose
end
end
@ -241,28 +239,26 @@ describe "String#split with Regexp" do
end
it "defaults to $; when regexp isn't given or nil" do
begin
verbose = $VERBOSE
$VERBOSE = nil
suppress_warning do
old_fs = $;
begin
[/,/, /:/, //, /XY/, /./].each do |fs|
$; = fs
[/,/, /:/, //, /XY/, /./].each do |fs|
$; = fs
["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str|
expected = str.split(fs)
["x,y,z,,,", "1:2:", "aXYbXYcXY", ""].each do |str|
expected = str.split(fs)
str.split(nil).should == expected
str.split.should == expected
str.split(nil).should == expected
str.split.should == expected
str.split(nil, -1).should == str.split(fs, -1)
str.split(nil, 0).should == str.split(fs, 0)
str.split(nil, 2).should == str.split(fs, 2)
str.split(nil, -1).should == str.split(fs, -1)
str.split(nil, 0).should == str.split(fs, 0)
str.split(nil, 2).should == str.split(fs, 2)
end
end
ensure
$; = old_fs
end
ensure
$; = old_fs
$VERBOSE = verbose
end
end

204
spec/ruby/core/string/swapcase_spec.rb
Просмотреть файл

@ -14,71 +14,61 @@ describe "String#swapcase" do
"hello".taint.swapcase.tainted?.should == true
end
ruby_version_is ''...'2.4' do
it "is locale insensitive (only upcases a-z and only downcases A-Z)" do
"ÄÖÜ".swapcase.should == "ÄÖÜ"
"ärger".swapcase.should == "äRGER"
"BÄR".swapcase.should == "bÄr"
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"äÖü".swapcase.should == "ÄöÜ"
end
it "updates string metadata" do
swapcased = "Aßet".swapcase
swapcased.should == "aSSET"
swapcased.size.should == 5
swapcased.bytesize.should == 5
swapcased.ascii_only?.should be_true
end
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"äÖü".swapcase.should == "ÄöÜ"
end
describe "ASCII-only case mapping" do
it "does not swapcase non-ASCII characters" do
"aßet".swapcase(:ascii).should == "AßET"
end
end
it "updates string metadata" do
swapcased = "Aßet".swapcase
swapcased.should == "aSSET"
swapcased.size.should == 5
swapcased.bytesize.should == 5
swapcased.ascii_only?.should be_true
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "swaps case of ASCII characters according to Turkic semantics" do
"aiS".swapcase(:turkic).should == "Aİs"
end
describe "ASCII-only case mapping" do
it "does not swapcase non-ASCII characters" do
"aßet".swapcase(:ascii).should == "AßET"
end
it "allows Lithuanian as an extra option" do
"aiS".swapcase(:turkic, :lithuanian).should == "Aİs"
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "swaps case of ASCII characters according to Turkic semantics" do
"aiS".swapcase(:turkic).should == "Aİs"
end
it "does not allow any other additional option" do
lambda { "aiS".swapcase(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Lithuanian as an extra option" do
"aiS".swapcase(:turkic, :lithuanian).should == "Aİs"
end
it "does not allow any other additional option" do
lambda { "aiS".swapcase(:turkic, :ascii) }.should raise_error(ArgumentError)
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"Iß".swapcase(:lithuanian).should == "iSS"
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"Iß".swapcase(:lithuanian).should == "iSS"
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"iS".swapcase(:lithuanian, :turkic).should == "İs"
end
it "does not allow any other additional option" do
lambda { "aiS".swapcase(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"iS".swapcase(:lithuanian, :turkic).should == "İs"
end
it "does not allow the :fold option for upcasing" do
lambda { "abc".swapcase(:fold) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { "aiS".swapcase(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow invalid options" do
lambda { "abc".swapcase(:invalid_option) }.should raise_error(ArgumentError)
end
it "does not allow the :fold option for upcasing" do
lambda { "abc".swapcase(:fold) }.should raise_error(ArgumentError)
end
it "does not allow invalid options" do
lambda { "abc".swapcase(:invalid_option) }.should raise_error(ArgumentError)
end
it "returns subclass instances when called on a subclass" do
@ -94,78 +84,76 @@ describe "String#swapcase!" do
a.should == "CyBeR_pUnK11"
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "äÖü"
a.swapcase!
a.should == "ÄöÜ"
end
it "updates string metadata" do
swapcased = "Aßet"
swapcased.swapcase!
swapcased.should == "aSSET"
swapcased.size.should == 5
swapcased.bytesize.should == 5
swapcased.ascii_only?.should be_true
end
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "äÖü"
a.swapcase!
a.should == "ÄöÜ"
end
describe "modifies self in place for ASCII-only case mapping" do
it "does not swapcase non-ASCII characters" do
a = "aßet"
a.swapcase!(:ascii)
a.should == "AßET"
end
it "updates string metadata" do
swapcased = "Aßet"
swapcased.swapcase!
swapcased.should == "aSSET"
swapcased.size.should == 5
swapcased.bytesize.should == 5
swapcased.ascii_only?.should be_true
end
end
describe "modifies self in place for ASCII-only case mapping" do
it "does not swapcase non-ASCII characters" do
a = "aßet"
a.swapcase!(:ascii)
a.should == "AßET"
end
end
describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do
it "swaps case of ASCII characters according to Turkic semantics" do
a = "aiS"
a.swapcase!(:turkic)
a.should == "Aİs"
end
describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do
it "swaps case of ASCII characters according to Turkic semantics" do
a = "aiS"
a.swapcase!(:turkic)
a.should == "Aİs"
end
it "allows Lithuanian as an extra option" do
a = "aiS"
a.swapcase!(:turkic, :lithuanian)
a.should == "Aİs"
end
it "does not allow any other additional option" do
lambda { a = "aiS"; a.swapcase!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
it "allows Lithuanian as an extra option" do
a = "aiS"
a.swapcase!(:turkic, :lithuanian)
a.should == "Aİs"
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "Iß"
a.swapcase!(:lithuanian)
a.should == "iSS"
end
it "does not allow any other additional option" do
lambda { a = "aiS"; a.swapcase!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "iS"
a.swapcase!(:lithuanian, :turkic)
a.should == "İs"
end
it "does not allow any other additional option" do
lambda { a = "aiS"; a.swapcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "Iß"
a.swapcase!(:lithuanian)
a.should == "iSS"
end
it "does not allow the :fold option for upcasing" do
lambda { a = "abc"; a.swapcase!(:fold) }.should raise_error(ArgumentError)
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "iS"
a.swapcase!(:lithuanian, :turkic)
a.should == "İs"
end
it "does not allow invalid options" do
lambda { a = "abc"; a.swapcase!(:invalid_option) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { a = "aiS"; a.swapcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow the :fold option for upcasing" do
lambda { a = "abc"; a.swapcase!(:fold) }.should raise_error(ArgumentError)
end
it "does not allow invalid options" do
lambda { a = "abc"; a.swapcase!(:invalid_option) }.should raise_error(ArgumentError)
end
it "returns nil if no modifications were made" do
a = "+++---111222???"
a.swapcase!.should == nil

1
spec/ruby/core/string/to_f_spec.rb
Просмотреть файл

@ -12,6 +12,7 @@ describe "String#to_f" do
".5".to_f.should == 0.5
".5e1".to_f.should == 5.0
"5.".to_f.should == 5.0
"5e".to_f.should == 5.0
"5E".to_f.should == 5.0
end

14
spec/ruby/core/string/unpack1_spec.rb
Просмотреть файл

@ -1,12 +1,10 @@
require_relative '../../spec_helper'
ruby_version_is "2.4" do
describe "String#unpack1" do
it "returns the first value of #unpack" do
"ABCD".unpack1('x3C').should == "ABCD".unpack('x3C')[0]
"\u{3042 3044 3046}".unpack1("U*").should == 0x3042
"aG9nZWZ1Z2E=".unpack1("m").should == "hogefuga"
"A".unpack1("B*").should == "01000001"
end
describe "String#unpack1" do
it "returns the first value of #unpack" do
"ABCD".unpack1('x3C').should == "ABCD".unpack('x3C')[0]
"\u{3042 3044 3046}".unpack1("U*").should == 0x3042
"aG9nZWZ1Z2E=".unpack1("m").should == "hogefuga"
"A".unpack1("B*").should == "01000001"
end
end

206
spec/ruby/core/string/upcase_spec.rb
Просмотреть файл

@ -8,77 +8,61 @@ describe "String#upcase" do
"hello".upcase.should == "HELLO"
end
ruby_version_is ''...'2.4' do
it "is locale insensitive (only replaces a-z)" do
"äöü".upcase.should == "äöü"
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"äöü".upcase.should == "ÄÖÜ"
end
str = Array.new(256) { |c| c.chr }.join
expected = Array.new(256) do |i|
c = i.chr
c.between?("a", "z") ? c.upcase : c
end.join
it "updates string metadata" do
upcased = "aßet".upcase
str.upcase.should == expected
upcased.should == "ASSET"
upcased.size.should == 5
upcased.bytesize.should == 5
upcased.ascii_only?.should be_true
end
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "works for all of Unicode with no option" do
"äöü".upcase.should == "ÄÖÜ"
end
describe "ASCII-only case mapping" do
it "does not upcase non-ASCII characters" do
"aßet".upcase(:ascii).should == "AßET"
end
end
it "updates string metadata" do
upcased = "aßet".upcase
upcased.should == "ASSET"
upcased.size.should == 5
upcased.bytesize.should == 5
upcased.ascii_only?.should be_true
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "upcases ASCII characters according to Turkic semantics" do
"i".upcase(:turkic).should == "İ"
end
describe "ASCII-only case mapping" do
it "does not upcase non-ASCII characters" do
"aßet".upcase(:ascii).should == "AßET"
end
it "allows Lithuanian as an extra option" do
"i".upcase(:turkic, :lithuanian).should == "İ"
end
describe "full Unicode case mapping adapted for Turkic languages" do
it "upcases ASCII characters according to Turkic semantics" do
"i".upcase(:turkic).should == "İ"
end
it "does not allow any other additional option" do
lambda { "i".upcase(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Lithuanian as an extra option" do
"i".upcase(:turkic, :lithuanian).should == "İ"
end
it "does not allow any other additional option" do
lambda { "i".upcase(:turkic, :ascii) }.should raise_error(ArgumentError)
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"iß".upcase(:lithuanian).should == "ISS"
end
describe "full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
"iß".upcase(:lithuanian).should == "ISS"
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"iß".upcase(:lithuanian, :turkic).should == "İSS"
end
it "does not allow any other additional option" do
lambda { "iß".upcase(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
"iß".upcase(:lithuanian, :turkic).should == "İSS"
end
it "does not allow the :fold option for upcasing" do
lambda { "abc".upcase(:fold) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { "iß".upcase(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow invalid options" do
lambda { "abc".upcase(:invalid_option) }.should raise_error(ArgumentError)
end
it "does not allow the :fold option for upcasing" do
lambda { "abc".upcase(:fold) }.should raise_error(ArgumentError)
end
it "does not allow invalid options" do
lambda { "abc".upcase(:invalid_option) }.should raise_error(ArgumentError)
end
it "taints result when self is tainted" do
@ -99,78 +83,76 @@ describe "String#upcase!" do
a.should == "HELLO"
end
ruby_version_is '2.4' do
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "äöü"
a.upcase!
a.should == "ÄÖÜ"
end
it "updates string metadata for self" do
upcased = "aßet"
upcased.upcase!
upcased.should == "ASSET"
upcased.size.should == 5
upcased.bytesize.should == 5
upcased.ascii_only?.should be_true
end
describe "full Unicode case mapping" do
it "modifies self in place for all of Unicode with no option" do
a = "äöü"
a.upcase!
a.should == "ÄÖÜ"
end
describe "modifies self in place for ASCII-only case mapping" do
it "does not upcase non-ASCII characters" do
a = "aßet"
a.upcase!(:ascii)
a.should == "AßET"
end
it "updates string metadata for self" do
upcased = "aßet"
upcased.upcase!
upcased.should == "ASSET"
upcased.size.should == 5
upcased.bytesize.should == 5
upcased.ascii_only?.should be_true
end
end
describe "modifies self in place for ASCII-only case mapping" do
it "does not upcase non-ASCII characters" do
a = "aßet"
a.upcase!(:ascii)
a.should == "AßET"
end
end
describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do
it "upcases ASCII characters according to Turkic semantics" do
a = "i"
a.upcase!(:turkic)
a.should == "İ"
end
describe "modifies self in place for full Unicode case mapping adapted for Turkic languages" do
it "upcases ASCII characters according to Turkic semantics" do
a = "i"
a.upcase!(:turkic)
a.should == "İ"
end
it "allows Lithuanian as an extra option" do
a = "i"
a.upcase!(:turkic, :lithuanian)
a.should == "İ"
end
it "does not allow any other additional option" do
lambda { a = "i"; a.upcase!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
it "allows Lithuanian as an extra option" do
a = "i"
a.upcase!(:turkic, :lithuanian)
a.should == "İ"
end
describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "iß"
a.upcase!(:lithuanian)
a.should == "ISS"
end
it "does not allow any other additional option" do
lambda { a = "i"; a.upcase!(:turkic, :ascii) }.should raise_error(ArgumentError)
end
end
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "iß"
a.upcase!(:lithuanian, :turkic)
a.should == "İSS"
end
it "does not allow any other additional option" do
lambda { a = "iß"; a.upcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
describe "modifies self in place for full Unicode case mapping adapted for Lithuanian" do
it "currently works the same as full Unicode case mapping" do
a = "iß"
a.upcase!(:lithuanian)
a.should == "ISS"
end
it "does not allow the :fold option for upcasing" do
lambda { a = "abc"; a.upcase!(:fold) }.should raise_error(ArgumentError)
it "allows Turkic as an extra option (and applies Turkic semantics)" do
a = "iß"
a.upcase!(:lithuanian, :turkic)
a.should == "İSS"
end
it "does not allow invalid options" do
lambda { a = "abc"; a.upcase!(:invalid_option) }.should raise_error(ArgumentError)
it "does not allow any other additional option" do
lambda { a = "iß"; a.upcase!(:lithuanian, :ascii) }.should raise_error(ArgumentError)
end
end
it "does not allow the :fold option for upcasing" do
lambda { a = "abc"; a.upcase!(:fold) }.should raise_error(ArgumentError)
end
it "does not allow invalid options" do
lambda { a = "abc"; a.upcase!(:invalid_option) }.should raise_error(ArgumentError)
end
it "returns nil if no modifications were made" do
a = "HELLO"
a.upcase!.should == nil

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше